Adding .gitignore and integrator filter

Author: Rayerdyne

.gitignore

@@ -0,0 +1,2 @@
+bin/
+bin/**

bin/ApplyEcho.class

@@ -15,6 +15,8 @@
  */
 public class IntegratorFilter implements FeedbackableFilter {
 
+    public static final double DEF_SAMPLING_FREQUENCY = 44100.0;
+
     private double integral;
     private double fs;
 
@@ -31,7 +33,7 @@ public IntegratorFilter (double fs) {
      * Constructor, uses default sampling frequency 44100 Hz
      */
     public IntegratorFilter() {
-        this(44100.0);
+        this(DEF_SAMPLING_FREQUENCY);
     }
 
 
@@ -76,4 +78,9 @@ public double[] incomingOutput() {
     public HashMap<String, String> getParameters() {
         return new HashMap<String, String>();
     }
+
+    /**
+     * @return      The sampling frequency, in Hz.
+     */
+    public double getSamplingFrequency() { return fs; }
 }

bin/CompositeExample.class

@@ -0,0 +1,76 @@
+package be.uliege.straet.oop.gui;
+
+import java.awt.Color;
+import java.awt.Graphics;
+
+import be.uliege.straet.oop.filters.IntegratorFilter;
+
+public class DIntegratorFilter extends DraggableFilter {
+
+    /** semi-height, actually */
+    public static final int HEIGHT = 30;
+    public static final int WIDTH = 20;
+
+    public static final int SYMBOL_HEIGHT = 20;
+    public static final int SYMBOL_RADIUS = 8;
+
+    public DIntegratorFilter(int x, int y, WorkSpace ws, boolean selected,
+        IntegratorFilter filter) {
+        super(x, y, ws, selected);
+
+        xCorners = new int[4];      yCorners = new int[4];
+        xCorners[0] = -WIDTH;   yCorners[0] = -HEIGHT;
+        xCorners[1] = WIDTH;    yCorners[1] = -HEIGHT;
+        xCorners[2] = WIDTH;    yCorners[2] = HEIGHT;
+        xCorners[3] = -WIDTH;   yCorners[3] = HEIGHT;
+        for (int i = 0; i < xCorners.length; i++) {
+            xCorners[i] += x;       yCorners[i] += y;
+        }
+
+        inputs = new FixedBall[1]; 
+        outputs = new FixedBall[1];
+        inputs[0] = new FixedBall(x - WIDTH, y, true, this);
+        outputs[0] = new FixedBall(x + WIDTH, y, false, this);
+
+        ws.addInputs(inputs);
+        ws.addOutputs(outputs);
+
+        color = Color.WHITE;
+
+        filterR = filter;
+        filterL = new IntegratorFilter(filter.getSamplingFrequency());
+        parameterD = new double[] { IntegratorFilter.DEF_SAMPLING_FREQUENCY };
+        parameterS = Double.toString(IntegratorFilter.DEF_SAMPLING_FREQUENCY);
+    }
+
+    public DIntegratorFilter(int x, int y, WorkSpace ws, boolean selected) {
+        this(x, y, ws, selected, new IntegratorFilter());
+    }
+
+    @Override
+    public int getParameterType() {  return DraggableFilter.DOUBLE;  }
+
+    @Override
+    public String getParameterInfo() 
+        {  return "sampling frequency in Hz";  }
+
+    @Override
+    public void paint(Graphics g, Color back, Color fore, double zoom) {
+        super.paint(g, back, fore, zoom);
+        g.drawPolygon(xCorners, yCorners, xCorners.length);
+        int sh = WorkSpace.zoom(SYMBOL_HEIGHT, zoom);
+        int sr = WorkSpace.zoom(SYMBOL_RADIUS, zoom);
+        g.drawLine(x, y - sh, x, y + sh);
+        g.drawArc(x, y - sh - sr/2, sr, sr, 0, 180);
+        g.drawArc(x - sr, y + sh - sr/2, sr, sr, 180, 180);
+    }
+    
+    @Override
+    public void setParameter(double[] d) {
+        if (d.length > 1)
+            return;
+        parameterD = d;
+        filterR = new IntegratorFilter(d[0]);
+        filterL = new IntegratorFilter(d[0]);
+    }
+}

bin/Demo.class

@@ -227,6 +227,7 @@ public void paint(Graphics g, Color back, Color fore, double zoom) {
         // painting of the parameters of the filter if there are some
         if (getParameterType() == NONE) return;
 
+        // painting filter's label
         g.setColor(Color.BLACK);
         String[] parts = parameterS.split("[/]");
         String toDraw = parts[parts.length - 1];

bin/DummyFilter.class

@@ -5,10 +5,11 @@
 import java.awt.Container;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
-import java.util.LinkedHashMap;
+import java.util.HashMap;
 
 import javax.swing.JFrame;
 import javax.swing.JPanel;
+import javax.swing.JComboBox;
 
 import be.uliege.montefiore.oop.audio.FilterException;
 
@@ -30,10 +31,12 @@ public class Window extends JFrame {
     /** It is a `LinkedHashMap` to be able to get the buttons in the order we
      * inserted them.
      */
-    private static LinkedHashMap<JButton, Procedure> buttonsActionsUp = 
-                                       new LinkedHashMap<JButton, Procedure>();
-    private static LinkedHashMap<JButton, Procedure> buttonsActionsDown = 
-                                       new LinkedHashMap<JButton, Procedure>();
+    private static HashMap<JButton, Procedure> buttonsActionsUp = 
+                                       new HashMap<JButton, Procedure>();
+    private static HashMap<JButton, Procedure> buttonsActionsDown = 
+                                       new HashMap<JButton, Procedure>();
+    String[] extraFilters = {"Composite", "Convolution", "Integrator"};
+    JComboBox<String> filterComboBox = new JComboBox<String>(extraFilters);
 
     public static void main(String[] args) {
         Window w = new Window(WINDOW_NAME);
@@ -52,14 +55,12 @@ public Window(String name) {
             catch (FilterException e) {
                 System.out.println(e.getMessage());
             }  });
-        buttonsActionsUp.put(new JButton("Addition"), () -> {ws.addAddition();});
-        buttonsActionsUp.put(new JButton("Delay"), () -> {ws.addDelay();});
-        buttonsActionsUp.put(new JButton("Gain"), () -> {ws.addGain();});
-        buttonsActionsUp.put(new JButton("Composite"), () -> {
-            try { ws.addComposite(); }
-            catch (Exception e) {
-                WorkSpace.showError("Could not add the composite filter", e);
-            }  });
+            buttonsActionsUp.put(new JButton("Delay"), () -> {ws.addDelay();});
+            buttonsActionsUp.put(new JButton("Gain"), () -> {ws.addGain();});
+                    buttonsActionsUp.put(new JButton("Other: "), () -> {
+                        addSelectedFilter();
+                    });
+            buttonsActionsUp.put(new JButton("Addition"), () -> {ws.addAddition();});
 
         buttonsActionsDown.put(new JButton("Variable"), 
             () -> {ws.addVariableDeclaration();});
@@ -71,7 +72,28 @@ public Window(String name) {
         new Thread(new RetardatorFocusGiver(ws)).start();
     }
 
-    private void initUi() {
+    private void addSelectedFilter() {
+        String filterType = (String) filterComboBox.getSelectedItem();
+        switch (filterType) {
+            case "Composite":
+                try { 
+                    ws.addComposite(); 
+                } catch (Exception e) {
+                    WorkSpace.showError("Could not add the composite filter", e);
+                }
+                break;
+            case "Convolution": 
+                ws.addConvolution();
+                break;
+            case "Integrator": 
+                ws.addIntegrator();
+                break;
+            default:
+                break;
+        }
+	}
+
+	private void initUi() {
 
         JPanel buttonsPanelUp = new JPanel();
         JPanel buttonsPanelDown = new JPanel();
@@ -96,6 +118,7 @@ public void actionPerformed(ActionEvent e) {
             buttonsPanelUp.add(b);
             b.addActionListener(bal);
         }
+        buttonsPanelUp.add(filterComboBox);
         for (JButton b : buttonsActionsDown.keySet()) {
             buttonsPanelDown.add(b);
             b.addActionListener(bal);

bin/Example.class

@@ -25,6 +25,7 @@
 import be.uliege.straet.oop.filters.ConvolutionFilter;
 import be.uliege.straet.oop.filters.DelayFilter;
 import be.uliege.straet.oop.filters.GainFilter;
+import be.uliege.straet.oop.filters.IntegratorFilter;
 import be.uliege.straet.oop.filters.WFilter;
 import be.uliege.straet.oop.loader.LoaderException;
 import be.uliege.straet.oop.loader.Writer;
@@ -406,6 +407,32 @@ public DraggableFilter addComposite(int x, int y, int orientation,
         filters.add(df);
         return df;
     }
+
+    /**
+     * Starts the placing of a integrator filter.
+     * @param x     The x coordinate of the filter
+     * @param y     The y coordinate of the filter
+     * @param orientation The orientation of the filter: the filter is oriented
+     *                    "normally" + orientation * 90° clockwise.
+     * @param selected    Wether or not the user is dragging this filter when 
+     *                    it is placed.
+     * @param filter      An `Integrator` that will be used in that 
+     *                    `DIntegratorFilter`
+     */
+    public DraggableFilter addIntegrator(int x, int y, int orientation, 
+        boolean selected, IntegratorFilter filter) {
+        DIntegratorFilter df = new DIntegratorFilter(x, y, this, selected, filter);
+        filters.add(df);
+        return df;
+    }
+
+    /** Starts the placing of a default integrator filter at (0, 0), needs 
+     * focus */
+    public void addIntegrator() {     
+        if (isBusy())  return; 
+        addIntegrator(0, 0, 0, true, new IntegratorFilter());
+    }
+
     /**
      * Starts the placing of an input filter.
      * @param x     The x coordinate of the filter