propane 0.5.0-java → 0.6.0-java

data/src/monkstone/slider/SimpleVerticalSlider.java

@@ -0,0 +1,159 @@
+/* 
+ * Copyright (c) 2016 Martin Prout
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package monkstone.slider;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import static processing.core.PConstants.HALF_PI;
+
+public class SimpleVerticalSlider extends SimpleSlider {
+    
+    final int SPACING = 20;
+    final int TOP_SPC = SPACING * 2;
+    final int BOTTOM_SPC = SPACING * 4;    
+
+    /**
+     *
+     * @param outer
+     * @param beginRange start range
+     * @param endRange end range
+     * @param initial
+     * @param count
+     */
+    public SimpleVerticalSlider(final PApplet outer, float beginRange, float endRange, float initial, int count) {
+        this.applet = outer;     
+        setActive(true);
+        pX = outer.width  - (TOP_SPC + count * SPACING);
+        pY = TOP_SPC;
+        pW = outer.height - BOTTOM_SPC;
+        pH = 10;
+        ID = Integer.toString(count + 1);
+        limits(beginRange, endRange);
+        
+    }
+
+   @Override
+    boolean mouseOver() {
+        return (applet.mouseX >= pX && applet.mouseX <= pX + pH && applet.mouseY >= pY && applet.mouseY <= pY + pW);
+    }
+
+    private void setActive(boolean active) {
+        if (active) {
+            applet.registerMethod("dispose", this);
+            applet.registerMethod("draw", this);
+        } else {
+            applet.unregisterMethod("draw", this);            
+        }
+    }
+
+@Override
+    void displayText() {
+        String lFormat = "%d";
+        if (displayLabel) {
+            applet.fill(labelColor);
+            applet.textSize(labelSize);
+            applet.textAlign(PConstants.CENTER);
+            applet.pushMatrix();
+            applet.translate(pX + pH / 2, pY + pW / 2);
+            applet.rotate(HALF_PI);
+            applet.text(Integer.toString((int) pValue), 0, 0 + labelSize / 2 - 2);
+            applet.popMatrix();
+        }
+        if (displayValue) {
+            applet.textSize(numberSize);
+            applet.fill(numbersColor);
+            applet.pushMatrix();
+            applet.textAlign(PConstants.RIGHT);
+            applet.translate(pX - numberSize / 2, pY);
+            applet.rotate(HALF_PI);
+            applet.text(String.format(lFormat, (int) vMax), 0, 0);
+            applet.popMatrix();
+            applet.pushMatrix();
+            applet.textAlign(PConstants.LEFT);
+            applet.translate(pX - numberSize / 2, pY + pW);
+            applet.rotate(HALF_PI);
+            applet.text(String.format(lFormat, (int) vMin), 0, 0);
+            applet.popMatrix();
+        }
+    }
+    
+    @Override
+    void drawGui() {
+        if (backgroundVisible) {
+            applet.fill(sliderBack);
+            applet.rect(pX, pY, pH, pW);
+        }
+        applet.fill(sliderFill);
+        applet.ellipse(pX + pH / 2, pY + pScaled, 10, 10);
+    }
+    
+    
+
+    /**
+     *
+     * @param value
+     */
+    @Override
+    public void setValue(float value) {
+        if (value > vMax) {
+            value = vMax;
+        }
+        if (value < vMin) {
+            value = vMin;
+        }
+        pValue = value;
+        pScaled = map(pValue, vMin, vMax, pW, 0);
+    }
+
+    @Override
+    void checkKeyboard() {
+        if (mouseOver()) {
+            if (applet.mousePressed && applet.mouseButton == PConstants.LEFT) {
+                pValue = constrainMap(applet.mouseY - pY, pW, 0, vMin, vMax);
+            }
+            if (applet.keyPressed && pressOnlyOnce) {
+                if (applet.keyCode == PConstants.LEFT || applet.keyCode == PConstants.DOWN) {
+                    pValue--;
+                }
+                if (applet.keyCode == PConstants.RIGHT || applet.keyCode == PConstants.UP) {
+                    pValue++;
+                }
+                if (pValue > vMax) {
+                    pValue = vMax;
+                } else {
+                    pValue = (pValue < vMin) ? vMin : pValue;
+                }
+                pressOnlyOnce = false;
+            }
+            deBounce(5);
+            pScaled = map(pValue, vMin, vMax, pW, 0);
+        }
+    }
+   
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        String geomF = "SimpleHSliderBar.new(%d, %d, %d, %.2f, %.2f, \"%s\")";
+        return String.format(geomF, pX, pY, pW, vMin, vMax, ID);
+    }
+}

data/src/monkstone/slider/Slider.java

@@ -0,0 +1,61 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package monkstone.slider;
+
+/**
+ *
+ * @author tux
+ */
+public interface Slider {
+
+    void dispose();
+
+    void draw();
+
+    /**
+     *
+     */
+    void hideBackground();
+
+    /**
+     *
+     */
+    void hideLabel();
+
+    /**
+     *
+     */
+    void hideNumbers();
+
+    /**
+     *
+     * @param s
+     */
+    void labelSize(int s);
+
+    /**
+     *
+     * @return
+     */
+    float readValue();
+
+    /**
+     *
+     * @param value
+     */
+    void setValue(float value);
+
+    /**
+     *
+     */
+    void showLabel();
+
+    /**
+     *
+     */
+    void showNumbers();
+    
+}

data/src/monkstone/slider/SliderBar.java

@@ -0,0 +1,245 @@
+/* 
+ * Copyright (c) 2016 Martin Prout
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package monkstone.slider;
+
+import processing.core.PApplet;
+import processing.event.MouseEvent;
+
+public abstract class SliderBar implements Slider {
+
+    int MIN_BAR_WIDTH = 10;
+    int MAX_BAR_WIDTH = 30;
+    int sliderBack = 0xff909090;
+    int sliderFill = 0xff696969;
+    int borderColor = 0;
+    int numbersColor = 0;
+    int labelColor = 0;
+    int externalBorder = 0;
+    boolean backgroundVisible = true;
+    int labelSize = 18;
+    int numberSize = 14;
+    boolean displayLabel = false;
+    boolean displayValue = true;
+    int pX;
+    int pY;
+    int pW;
+    int pH;
+    float pScaled = 0;
+    float pValue = 0;
+    String ID;
+    boolean pressOnlyOnce = true;
+    int deb = 0;
+    short wheelCount = 0;
+    float vMin = 0;
+    float vMax = 15;
+    PApplet applet;
+    WheelHandler scrollWheelHandler;
+
+    /**
+     *
+     * @return
+     */
+    public float value() {
+        return pValue;
+    }
+
+    /**
+     *
+     * @param w
+     */
+    public void barWidth(int w) {
+        if (w < MIN_BAR_WIDTH) {
+            pH = MIN_BAR_WIDTH;
+        } else {
+            pH = (w > MAX_BAR_WIDTH) ? MAX_BAR_WIDTH : w;
+        }
+    }
+
+    final void limits(float iv, float fv) {
+        vMin = iv;
+        vMax = fv;
+        SliderBar.this.setValue(iv);
+    }
+
+    /**
+     *
+     */
+    @Override
+    public void showLabel() {
+        displayLabel = true;
+    }
+
+    /**
+     *
+     */
+    @Override
+    public void hideLabel() {
+        displayLabel = false;
+    }
+
+    /**
+     *
+     */
+    @Override
+    public void showNumbers() {
+        displayValue = true;
+    }
+
+    /**
+     *
+     */
+    @Override
+    public void hideNumbers() {
+        displayValue = false;
+    }
+
+    /**
+     *
+     * @param b
+     */
+    public void externalBorder(int b) {
+        externalBorder = b;
+    }
+
+    /**
+     *
+     */
+    @Override
+    public void hideBackground() {
+        backgroundVisible = false;
+    }
+
+    /**
+     *
+     */
+    public void showBackground() {
+        backgroundVisible = true;
+    }
+
+    /**
+     *
+     * @param s
+     */
+    @Override
+    public void labelSize(int s) {
+        labelSize = (s < 4) ? 4 : s;
+    }
+
+    /**
+     * @param back color of the bar
+     * @param fill background color of the slider
+     */
+    public void widgetColors(int back, int fill) {
+        sliderBack = back;
+        sliderFill = fill;
+    }
+
+    abstract boolean mouseOver();
+
+    private void setActive(boolean active) {
+        if (active) {
+            applet.registerMethod("dispose", this);
+            applet.registerMethod("draw", this);
+            applet.registerMethod("mouseEvent", this);
+        } else {
+            applet.unregisterMethod("draw", this);
+            applet.unregisterMethod("mouseEvent", this);
+        }
+    }
+
+    abstract void displayText();
+
+    abstract void drawGui();
+
+    @Override
+    public void draw() {
+        applet.pushStyle();
+        applet.noStroke();
+        drawGui();
+        displayText();
+        applet.popStyle();
+        change();
+    }
+
+    public void mouseEvent(MouseEvent evt) {
+        if (evt.getAction() == MouseEvent.WHEEL) {
+            if (scrollWheelHandler != null) {
+                scrollWheelHandler.handleWheel((short) evt.getCount());
+            }
+        }
+    }
+
+    /**
+     *
+     * @param value
+     */
+    @Override
+    public abstract void setValue(float value);
+
+    abstract void checkKeyboard();
+
+    void change() {
+        checkKeyboard();
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public float readValue() {
+        return pValue;
+    }
+
+    /**
+     *
+     * @param delta
+     */
+    abstract void changeWithWheel(int delta);
+
+    void deBounce(int n) {
+        if (pressOnlyOnce) {
+        } else if (deb++ > n) {
+            deb = 0;
+            pressOnlyOnce = true;
+        }
+    }
+
+    protected float map(float val, float begIn, float endIn, float beginOut, float endOut) {
+        return (beginOut + (endOut - beginOut) * ((val - begIn) / (endIn - begIn)));
+    }
+
+    protected int constrainMap(double val, double begIn, double endIn, double beginOut, double endOut) {
+        double max = Math.max(begIn, endIn);
+        double min = Math.min(begIn, endIn);
+        if (val < min) {
+            val = min;
+        }
+        if (val > max) {
+            val = max;
+        }
+        return (int) ((beginOut + (endOut - beginOut) * ((val - begIn) / (endIn - begIn))));
+    }
+
+    @Override
+    public void dispose() {
+        setActive(false);
+    }
+}