_Presets.pde

   1 interface PresetListener {
   2   public void onPresetLoaded(Preset preset);
   3   public void onPresetDirty(Preset preset);
   4   public void onPresetStored(Preset preset);
   5   public void onPresetUnloaded();
   6 }
   7
   8 class PresetManager implements LXParameter.Listener {
   9
  10   public static final int NUM_PRESETS = 8;
  11   public static final String FILENAME = "data/presets.txt";
  12   public static final String DELIMITER = "\t";
  13
  14   private final Preset[] presets = new Preset[NUM_PRESETS];
  15   private final List<PresetListener> listeners = new ArrayList<PresetListener>();
  16
  17   private Preset loadedPreset = null;
  18   private LXPattern loadedPattern = null;
  19
  20   PresetManager() {
  21     for (int i = 0; i < presets.length; ++i) {
  22       presets[i] = new Preset(this, i);
  23     }
  24     String[] values = loadStrings(FILENAME);
  25     if (values == null) {
  26       write();
  27     } else {
  28       int i = 0;
  29       for (String serialized : values) {
  30         presets[i++].load(serialized);
  31         if (i >= NUM_PRESETS) {
  32           break;
  33         }
  34       }
  35     }
  36     for (Engine.Deck deck : lx.engine.getDecks()) {
  37       deck.addListener(new Engine.AbstractListener() {
  38         public void patternDidChange(Engine.Deck deck, LXPattern pattern) {
  39           if (midiEngine.getFocusedDeck() == deck) {
  40             if (pattern != loadedPattern) {
  41               onPresetDirty();
  42             }
  43           }
  44         }
  45       });
  46     }
  47   }
  48
  49   public void setMidiEngine(MidiEngine midiEngine) {
  50     midiEngine.addListener(new MidiEngineListener() {
  51       public void onFocusedDeck(int deckIndex) {
  52         loadedPreset = null;
  53         for (PresetListener listener : listeners) {
  54           listener.onPresetUnloaded();
  55         }
  56       }
  57     });
  58   }
  59
  60   public void addListener(PresetListener listener) {
  61     listeners.add(listener);
  62   }
  63
  64   public void select(int index) {
  65     presets[index].select();
  66   }
  67
  68   public void store(int index) {
  69     presets[index].store(midiEngine.getFocusedPattern());
  70     for (PresetListener listener : listeners) {
  71       listener.onPresetStored(presets[index]);
  72     }
  73     select(index);
  74   }
  75
  76   public void onPresetLoaded(Preset preset, LXPattern pattern) {
  77     if (loadedPattern != pattern) {
  78       if (loadedPattern != null) {
  79         for (LXParameter p : loadedPattern.getParameters()) {
  80           ((LXListenableParameter) p).removeListener(this);
  81         }
  82       }
  83     }
  84     for (PresetListener listener : listeners) {
  85       listener.onPresetLoaded(preset);
  86     }
  87     loadedPreset = preset;
  88     loadedPattern = pattern;
  89     for (LXParameter p : loadedPattern.getParameters()) {
  90       ((LXListenableParameter) p).addListener(this);
  91     }
  92   }
  93
  94   private void onPresetDirty() {
  95     for (PresetListener listener : listeners) {
  96       listener.onPresetDirty(loadedPreset);
  97     }
  98   }
  99
 100   public void onParameterChanged(LXParameter p) {
 101     onPresetDirty();
 102   }
 103
 104   public void write() {
 105     String[] lines = new String[NUM_PRESETS];
 106     int i = 0;
 107     for (Preset preset : presets) {
 108       lines[i++] = preset.serialize();
 109     }
 110     saveStrings(FILENAME, lines);
 111   }
 112 }
 113
 114 class Preset {
 115
 116   final PresetManager manager;
 117   final int index;
 118
 119   String className;
 120   final Map<String, Float> parameters = new HashMap<String, Float>();
 121
 122   Preset(PresetManager manager, int index) {
 123     this.manager = manager;
 124     this.index = index;
 125   }
 126
 127   public void load(String serialized) {
 128     className = null;
 129     parameters.clear();
 130     try {
 131       String[] parts = serialized.split(PresetManager.DELIMITER);
 132       className = parts[0];
 133       int i = 1;
 134       while (i < parts.length - 1) {
 135         parameters.put(parts[i], Float.parseFloat(parts[i+1]));
 136         i += 2;
 137       }
 138     } catch (Exception x) {
 139       className = null;
 140       parameters.clear();
 141     }
 142   }
 143
 144   public String serialize() {
 145     if (className == null) {
 146       return "null";
 147     }
 148     String val = className + PresetManager.DELIMITER;
 149     for (String pKey : parameters.keySet()) {
 150       val += pKey + PresetManager.DELIMITER + parameters.get(pKey) + PresetManager.DELIMITER;
 151     }
 152     return val;
 153   }
 154
 155   public void store(LXPattern pattern) {
 156     className = null;
 157     parameters.clear();
 158     className = pattern.getClass().getName();
 159     for (LXParameter p : pattern.getParameters()) {
 160       parameters.put(p.getLabel(), p.getValuef());
 161     }
 162     manager.write();
 163   }
 164
 165   public void select() {
 166     Engine.Deck deck = midiEngine.getFocusedDeck();
 167     for (LXPattern pattern : deck.getPatterns()) {
 168       if (pattern.getClass().getName().equals(className)) {
 169         for (String pLabel : parameters.keySet()) {
 170           for (LXParameter p : pattern.getParameters()) {
 171             if (p.getLabel().equals(pLabel)) {
 172               p.setValue(parameters.get(pLabel));
 173             }
 174           }
 175         }
 176         deck.goPattern(pattern);
 177         manager.onPresetLoaded(this, pattern);
 178         break;
 179       }
 180     }
 181   }
 182 }
 183