view/std/PianoRoll.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2005-2008 Grigor Iliev <grigor@grigoriliev.com>
 *
 *   This file is part of JSampler.
 *
 *   JSampler is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   JSampler 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 General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with JSampler; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *   MA  02111-1307  USA
 */

package org.jsampler.view.std;

import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.RenderingHints;

import java.awt.event.MouseEvent;
import java.awt.event.MouseAdapter;

import java.awt.geom.RoundRectangle2D;

import java.util.Vector;

import javax.swing.JPanel;

import org.linuxsampler.lscp.event.MidiDataEvent;
import org.linuxsampler.lscp.event.MidiDataListener;

/**
 *
 * @author Grigor Iliev
 */
public class PianoRoll extends JPanel implements MidiDataListener {
        public class Key {
                private boolean disabled = false;
                private boolean pressed = false;
                private boolean keyswitch = false;
                
                public
                Key() {
                        
                }
                
                public boolean
                isDisabled() { return disabled; }
                
                public void
                setDisabled(boolean b) { disabled = b; }
                
                public boolean
                isPressed() { return pressed; }
                
                public void
                setPressed(boolean b) { pressed = b; }
                
                public boolean
                isKeyswitch() { return keyswitch; }
                
                public void
                setKeyswitch(boolean b) { keyswitch = b; }
                
        }
        
        
        private final Vector<Key> keys = new Vector<Key>();
        
        private boolean vertical;
        private boolean mirror;
        private boolean octaveLabelsVisible = true;
        private boolean playingEnabled = true;
        
        private int firstKey = -1;
        private int lastKey = -1;
        private int whiteKeyCount = 68;
        
        private Color borderColor = Color.BLACK;
        private Color keyColor = Color.WHITE;
        private Color disabledKeyColor = Color.GRAY;
        private Color pressedKeyColor = Color.GREEN;
        private Color keySwitchColor = Color.PINK;
        private Color blackKeyColor = Color.BLACK;
        
        private final Vector<MidiDataListener> listeners = new Vector<MidiDataListener>();
        
        private boolean shouldRepaint = false;
        
        /**
         * Creates a new horizontal, not mirrored <code>PianoRoll</code>.
         */
        public
        PianoRoll() { this(false); }
        
        /**
         * Creates a new not mirrored <code>PianoRoll</code>.
         * @param vertical Specifies whether the piano roll
         * should be vertical or horizontal
         */
        public
        PianoRoll(boolean vertical) { this(vertical, false); }
        
        /**
         * Creates a new instance of <code>PianoRoll</code>.
         * @param vertical Specifies whether the piano roll
         * should be vertical or horizontal.
         * @param mirror Specifies whether to mirror the piano roll.
         */
        public
        PianoRoll(boolean vertical, boolean mirror) {
                this.vertical = vertical;
                this.mirror = mirror;
                
                this.addMouseListener(getHandler());
                setKeyRange(0, 127);
        }
        
        /**
         * Registers the specified listener to be notified when
         * MIDI event occurs due to user input.
         * @param l The <code>MidiDataListener</code> to register.
         */
        public void
        addMidiDataListener(MidiDataListener l) { listeners.add(l); }
        
        /**
         * Removes the specified listener.
         * @param l The <code>MidiDataListener</code> to remove.
         */
        public void
        removeMidiDataListener(MidiDataListener l) { listeners.remove(l); }
        
        private void
        fireMidiDataEvent(MidiDataEvent e) {
                for(MidiDataListener l : listeners) l.midiDataArrived(e);
        }
        
        /**
         * Determines whether the user input is processed
         * and respective MIDI data events are sent.
         */
        public boolean
        isPlayingEnabled() { return playingEnabled; }
        
        /**
         * Sets whether the user input should be processed
         * and respective MIDI data events should be sent.
         * @see #isPlayingEnabled
         */
        public void
        setPlayingEnabled(boolean b) { playingEnabled = b; }
        
        public boolean
        hasKey(int key) {
                if(key >= firstKey && key <= lastKey) return true;
                return false;
        }
        
        public Key
        getKey(int key) { return keys.get(key - firstKey); }
        
        public boolean
        isKeyDisabled(int key) {
                return getKey(key).isDisabled();
        }
        
        public void
        setKeyDisabled(int key, boolean disable) {
                Key k = getKey(key);
                if(k.isDisabled() == disable) return;
                
                getKey(key).setDisabled(disable);
                if(getShouldRepaint()) repaint();
        }
        
        public boolean
        isKeyPressed(int key) {
                return getKey(key).isPressed();
        }
        
        public void
        setKeyPressed(int key, boolean press) {
                Key k = getKey(key);
                if(k.isPressed() == press) return;
                
                getKey(key).setPressed(press);
                if(getShouldRepaint()) repaint(getKeyRectangle(key));
        }
        
        public boolean
        isKeyswitch(int key) {
                return getKey(key).isKeyswitch();
        }
        
        public void
        setKeyswitch(int key, boolean keyswitch) {
                Key k = getKey(key);
                if(k.isKeyswitch() == keyswitch) return;
                
                getKey(key).setKeyswitch(keyswitch);
                if(getShouldRepaint()) repaint(getKeyRectangle(key));
        }
        
        public void
        setAllKeysPressed(boolean b) {
                boolean changed = false;
                for(Key key : keys) {
                        if(key.isPressed() != b) {
                                key.setPressed(b);
                                changed = true;
                        }
                }
                
                if(changed && getShouldRepaint()) repaint();
        }
        
        public void
        setAllKeysDisabled(boolean b) {
                boolean changed = false;
                for(Key key : keys) {
                        if(key.isDisabled() != b) {
                                key.setDisabled(b);
                                changed = true;
                        }
                }
                
                if(changed && getShouldRepaint()) repaint();
        }
        
        public Integer[]
        getKeyswitches() {
                Vector<Integer> v = new Vector<Integer>();
                for(int i = 0; i < keys.size(); i++) {
                        if(keys.get(i).isKeyswitch()) v.add(firstKey + i);
                }
                
                return v.toArray(new Integer[v.size()]);
        }
        
        /**
         * Keys outside the keyboard range are ignored.
         * @param keys List of keys
         */
        public void
        setKeyswitches(Integer[] keys, boolean keyswitches) {
                boolean changed = false;
                for(int k : keys) {
                        if(!hasKey(k)) continue;
                        if(getKey(k).isKeyswitch() != keyswitches) {
                                getKey(k).setKeyswitch(keyswitches);
                                changed = true;
                        }
                }
                if(changed && getShouldRepaint()) repaint();
        }
        
        public Integer[]
        getEnabledKeys() {
                Vector<Integer> v = new Vector<Integer>();
                for(int i = 0; i < keys.size(); i++) {
                        if(!keys.get(i).isDisabled()) v.add(firstKey + i);
                }
                
                return v.toArray(new Integer[v.size()]);
        }
        
        /**
         * Enables or disables the specified list of keys.
         * Keys outside the keyboard range are ignored.
         * @param keys List of keys
         */
        public void
        setDisabled(Integer[] keys, boolean disable) {
                boolean changed = false;
                for(int k : keys) {
                        if(!hasKey(k)) continue;
                        if(getKey(k).isDisabled() != disable) {
                                getKey(k).setDisabled(disable);
                                changed = true;
                        }
                }
                if(changed && getShouldRepaint()) repaint();
        }
        
        public void
        removeAllKeyswitches() {
                boolean changed = false;
                for(Key key : keys) {
                        if(key.isKeyswitch()) {
                                key.setKeyswitch(false);
                                changed = true;
                        }
                }
                if(changed && getShouldRepaint()) repaint();
        }
        
        /**
         * Sets the piano key range which this piano roll will provide.
         * Note that the specified last key is also included in the piano roll.
         * Also, the first and the last key should be white keys. If the first key 
         * and/or the last key are not white keys then the range is extended automatically.
         * @param firstKey Number between 0 and 127 (inclusive) as specified in the MIDI standard.
         * @param lastKey Number between 0 and 127 (inclusive) as specified in the MIDI standard.
         * @throws IllegalArgumentException if the specified range is invalid.
         */
        public void
        setKeyRange(int firstKey, int lastKey) {
                if(this.firstKey == firstKey && this.lastKey == lastKey) return;
                
                if(firstKey < 0 || firstKey > 127 || lastKey < 0 || lastKey > 127 || firstKey >= lastKey) {
                        throw new IllegalArgumentException("Invalid range: " + firstKey + "-" + lastKey);
                }
                
                /*Integer[] enabledKeys = getEnabledKeys();
                Integer[] keyswitches = getKeyswitches();*/
                
                if(!isWhiteKey(firstKey)) firstKey--;
                if(!isWhiteKey(lastKey)) lastKey++;
                this.firstKey = firstKey;
                this.lastKey = lastKey;
                
                keys.removeAllElements();
                for(int i = 0; i <= lastKey - firstKey; i++) keys.add(new Key());
                
                whiteKeyCount = getWhiteKeyCount(firstKey, lastKey);
                
                /*setAllKeysDisabled(true);
                setDisabled(enabledKeys, false);
                setKeyswitches(keyswitches, true);*/
                
                if(getShouldRepaint()) repaint();
        }
        
        public boolean
        getOctaveLabelsVisible() {
                return octaveLabelsVisible;
        }
        
        public void
        setOctaveLabelsVisible(boolean b) {
                octaveLabelsVisible = b;
        }
        
        /**
         * Gets the number of white keys int the specified range (inclusive).
         * @see #setKeyRange
         */
        private static int
        getWhiteKeyCount(int firstKey, int lastKey) {
                int count = 0;
                for(int j = firstKey; j <= lastKey; j++) { // FIXME: Stupid but works
                        if(isWhiteKey(j)) count++;
                }
                
                return count;
        }
        
        private int
        getWhiteKeyByNumber(int whiteKey) {
                int count = 0;
                for(int j = firstKey; j <= lastKey; j++) { // FIXME: Stupid but works
                        if(isWhiteKey(j)) {
                                if(whiteKey == count) return j;
                                count++;
                        }
                }
                
                return -1;
        }
        
        private int
        getWhiteKeyCount() {
                return whiteKeyCount;
        }
        
        /**
         * Determines whether the specified key is a white key.
         * @param key Number between 0 and 127 (inclusive) as specified in the MIDI standard.
         */
        public static boolean
        isWhiteKey(int key) {
                if(key < 0 || key > 127) return false;
                
                int k = key % 12;
                if(k == 1 || k == 3 || k == 6 || k == 8 || k == 10) {
                        return false;
                }
                
                return true;
        }
        
        /**
         * Returns the position (zero-based) of the specified white key in the octave.
         * @param whiteKey Number between 0 and 127 (inclusive) as specified in the MIDI standard.
         * @return Number between 0 and 6 (inclusive) and -1 if the
         * specified key is not a white key.
         */
        public static int
        getKeyOctaveIndex(int whiteKey) {
                if(whiteKey < 0 || whiteKey > 127) return -1;
                
                int k = whiteKey % 12;
                if(k == 1 || k == 3 || k == 6 || k == 8 || k == 10) {
                        return -1;
                }
                
                return getWhiteKeyCount(0, k) - 1;
        }
        
        private Color
        getKeyColor(int key) {
                Key k = getKey(key);
                if(isWhiteKey(key)) {
                        if(k.isPressed()) return pressedKeyColor;
                        if(k.isKeyswitch()) return keySwitchColor;
                        if(k.isDisabled()) return disabledKeyColor;
                        return keyColor;
                } else {
                        if(k.isPressed()) return Color.GREEN;
                        return blackKeyColor;
                }
        }
        
        /**
         * Releases all pressed keys, enables all keys and removes all keyswitches.
         */
        public void
        reset() { reset(false); }
        
        /**
         * Releases all pressed keys, enables/disables all keys and removes all keyswitches.
         * @param dissable Specifies whether all keys should be enabled or disabled
         */
        public void
        reset(boolean dissableAllKeys) {
                boolean b = getShouldRepaint();
                setShouldRepaint(false);
                setAllKeysPressed(false);
                removeAllKeyswitches();
                setAllKeysDisabled(dissableAllKeys);
                setShouldRepaint(b);
                if(getShouldRepaint()) repaint();
        }
        
        public boolean
        getShouldRepaint() { return shouldRepaint; }
        
        public void
        setShouldRepaint(boolean b) { shouldRepaint = b; }
        
        private int
        getKey(Point p) {
                double w = getWhiteKeyWidth() + /* space between keys */ 1.0d;
                if(w == 0) return -1;
                int whiteKeyNumber = (int) (p.getX() / w);
                double leftBorder = whiteKeyNumber * w;
                int key = getWhiteKeyByNumber(whiteKeyNumber);
                if(key == -1) return -1;
                
                double bh = getBlackKeyHeight();
                double blackKeyOffset = w / 4.0d;
                if(p.getY() > bh) return key;
                if(key != firstKey && !isWhiteKey(key - 1)) {
                        if(p.getX() <= leftBorder + blackKeyOffset) return key - 1;
                }
                if(key != lastKey && !isWhiteKey(key + 1)) {
                        if(p.getX() >= leftBorder + 3 * blackKeyOffset - 3) return key + 1;
                }
                
                return key;
        }
        
        private int
        getVelocity(Point p, boolean whiteKey) {
                double h = whiteKey ? getWhiteKeyHeight() : getBlackKeyHeight();
                int velocity = (int) ((p.getY() / h) * 127.0d + 1);
                if(velocity < 0) velocity = 0;
                if(velocity > 127) velocity = 127;
                return velocity;
        }
        
        private double
        getWhiteKeyWidth() {
                double w = getSize().getWidth();
                return (w - getWhiteKeyCount()) / getWhiteKeyCount();
        }
        
        private double
        getWhiteKeyHeight() {
                return getSize().getHeight() - 3.0d;
        }
        
        private double
        getBlackKeyWidth() {
                return getWhiteKeyWidth() / 2.0d;
        }
        
        private double
        getBlackKeyHeight() {
                return getWhiteKeyHeight() / 1.5d;
        }
        
        protected void
        paintOctaveLabel(Graphics2D g, int octave, int whiteKeyIndex) {
                double h = getSize().getHeight();
                double whiteKeyWidth = getWhiteKeyWidth();
                g.setPaint(Color.BLACK);
                int fsize = (int) (whiteKeyWidth / (1.5 + whiteKeyWidth / 50));
                if(fsize < 8) fsize = 8;
                g.setFont(g.getFont().deriveFont(Font.BOLD, fsize));
                
                float x = (float) (whiteKeyWidth * whiteKeyIndex + whiteKeyIndex);
                float y = (float) (h - 1);
                
                String s = String.valueOf(octave);
                FontMetrics fm = g.getFontMetrics();
                
                // center text
                int i = fm.stringWidth(s);
                if(i < whiteKeyWidth) {
                        x += (whiteKeyWidth - i) / 2;
                } else {
                        x += 2;
                }
                
                y -= (h / 12);
                
                g.drawString(s, x, y);
        }
        
        /**
         * Gets the rectangle in which the key is drawn and empty rectangle
         * if the specified key is not shown on the piano roll or is invalid.
         */
        public Rectangle
        getKeyRectangle(int key) {
                Rectangle r = new Rectangle();
                if(!hasKey(key)) return r;
                
                int whiteKeyIndex = getWhiteKeyCount(firstKey, key) - 1;
                
                if(isWhiteKey(key)) {
                        double whiteKeyWidth = getWhiteKeyWidth();
                        double whiteKeyHeight = getWhiteKeyHeight();
                        double x = whiteKeyWidth * whiteKeyIndex + whiteKeyIndex;
                        r.setRect(x, 0, whiteKeyWidth, whiteKeyHeight);
                } else {
                        double blackKeyWidth = getBlackKeyWidth();
                        double blackKeyHeight = getBlackKeyHeight();
                        int i = whiteKeyIndex;
                        double x = blackKeyWidth * (2*(i + 1)) - blackKeyWidth * 0.5d + i;
                        r.setRect(x, 0, blackKeyWidth, blackKeyHeight);
                }
                
                return r;
        }
        
        @Override public void
        paint(Graphics g) {
                super.paint(g);
                Graphics2D g2 = (Graphics2D) g;
                
                double whiteKeyWidth = getWhiteKeyWidth();
                double whiteKeyHeight = getWhiteKeyHeight();
                double arcw = whiteKeyWidth/4.0d;
                double arch = whiteKeyHeight/14.0d;
                
                g2.setPaint(keyColor);
                
                RoundRectangle2D.Double rect;
                
                g2.setRenderingHint (
                        RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF
                );
                
                int i = 0;
                for(int j = firstKey; j <= lastKey; j++) {
                        if(!isWhiteKey(j)) continue;
                        
                        Color c = getKeyColor(j);
                        if(g2.getPaint() != c) g2.setPaint(c);
                        
                        rect = new RoundRectangle2D.Double (
                                // If you change this you should also change getKeyRectangle()
                                whiteKeyWidth * i + i, 0,
                                whiteKeyWidth, whiteKeyHeight,
                                arcw, arch
                        );
                        
                        g2.fill(rect);
                        i++;
                }
                
                g2.setRenderingHint (
                        RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON
                );
                
                g2.setStroke(new java.awt.BasicStroke(1.5f));
                g2.setPaint(borderColor);
                
                i = 0;
                for(int j = firstKey; j <= lastKey; j++) {
                        if(!isWhiteKey(j)) continue;
                        
                        rect = new RoundRectangle2D.Double (
                                whiteKeyWidth * i + i, 0,
                                whiteKeyWidth, whiteKeyHeight,
                                arcw, arch
                        );
                
                        g2.draw(rect);
                        i++;
                }
                
                
                g2.setStroke(new java.awt.BasicStroke(2.5f));
                double blackKeyWidth = getBlackKeyWidth();
                double blackKeyHeight = getBlackKeyHeight();
                
                i = 0;
                for(int j = firstKey; j <= lastKey; j++) {
                        if(getOctaveLabelsVisible() && j % 12 == 0) {
                                int octave = j / 12 - 2;
                                paintOctaveLabel(g2, octave, i);
                        }
                        if(!isWhiteKey(j)) continue;
                        
                        int k = (i + getKeyOctaveIndex(firstKey)) % 7;
                        if(k == 2 || k == 6) { i++; continue; }
                        
                        Color c = (j == lastKey) ? blackKeyColor : getKeyColor(j + 1);
                        if(g2.getPaint() != c) g2.setPaint(c);
                        
                        // If you change this you should also change getKeyRectangle()
                        double x = blackKeyWidth * (2*(i + 1)) - blackKeyWidth * 0.5d + i;
                        rect = new RoundRectangle2D.Double (
                                // If you change this you should also change getKeyRectangle()
                                x, 0,
                                blackKeyWidth, blackKeyHeight,
                                arcw, arch
                        );
                        ///////
                        
                        boolean pressed = (j == lastKey) ? false : getKey(j + 1).isPressed();
                        if(!pressed) g2.fill(rect);
                        
                        RoundRectangle2D.Double rect2;
                        rect2 = new RoundRectangle2D.Double (
                                x, 0,
                                blackKeyWidth, arch,
                                arcw, arch / 1.8d
                        );
                        
                        g2.fill(rect2);
                        g2.setPaint(borderColor);
                        g2.draw(rect);
                        
                        if(pressed) {
                        GradientPaint gr = new GradientPaint (
                                (float)(x + blackKeyWidth/2), (float)(blackKeyHeight/4), Color.BLACK,
                                (float)(x + blackKeyWidth/2), (float)blackKeyHeight, new Color(0x058a02)
                        );
                        g2.setPaint(gr);
                        g2.fill(rect);
                        }
                        i++;
                }
        }
        
        @Override public void
        midiDataArrived(MidiDataEvent e) {
                switch(e.getType()) {
                        case NOTE_ON:
                                setKeyPressed(e.getNote(), true);
                                break;
                        case NOTE_OFF:
                                setKeyPressed(e.getNote(), false);
                }
        }
        
        private final Handler handler = new Handler();
        
        private Handler
        getHandler() { return handler; }
        
        private class Handler extends MouseAdapter {
                private int pressedKey = -1;
                
                @Override public void
                mousePressed(MouseEvent e) {
                        if(!isPlayingEnabled()) return;
                        if(e.getButton() != MouseEvent.BUTTON1) return;
                        
                        int key = getKey(e.getPoint());
                        if(key == -1) return;
                        pressedKey = key;
                        setKeyPressed(key, true);
                        int velocity = getVelocity(e.getPoint(), isWhiteKey(key));
                        
                        MidiDataEvent evt = new MidiDataEvent (
                                PianoRoll.this, MidiDataEvent.Type.NOTE_ON, key, velocity
                        );
                        
                        fireMidiDataEvent(evt);
                }
                
                @Override public void
                mouseReleased(MouseEvent e) {
                        if(!isPlayingEnabled()) return;
                        if(e.getButton() != MouseEvent.BUTTON1) return;
                        
                        if(pressedKey == -1) return;
                        setKeyPressed(pressedKey, false);
                        
                        int velocity = getVelocity(e.getPoint(), isWhiteKey(pressedKey));
                        MidiDataEvent evt = new MidiDataEvent (
                                PianoRoll.this, MidiDataEvent.Type.NOTE_OFF, pressedKey, velocity
                        );
                        
                        pressedKey = -1;
                        
                        fireMidiDataEvent(evt);
                }
        }
}
1	/*
2	* JSampler - a java front-end for LinuxSampler
3	*
4	* Copyright (C) 2005-2008 Grigor Iliev <grigor@grigoriliev.com>
5	*
6	* This file is part of JSampler.
7	*
8	* JSampler is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License version 2
10	* as published by the Free Software Foundation.
11	*
12	* JSampler is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with JSampler; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20	* MA 02111-1307 USA
21	*/
22
23	package org.jsampler.view.std;
24
25	import java.awt.Color;
26	import java.awt.Font;
27	import java.awt.FontMetrics;
28	import java.awt.GradientPaint;
29	import java.awt.Graphics;
30	import java.awt.Graphics2D;
31	import java.awt.Point;
32	import java.awt.Rectangle;
33	import java.awt.RenderingHints;
34
35	import java.awt.event.MouseEvent;
36	import java.awt.event.MouseAdapter;
37
38	import java.awt.geom.RoundRectangle2D;
39
40	import java.util.Vector;
41
42	import javax.swing.JPanel;
43
44	import org.linuxsampler.lscp.event.MidiDataEvent;
45	import org.linuxsampler.lscp.event.MidiDataListener;
46
47	/**
48	*
49	* @author Grigor Iliev
50	*/
51	public class PianoRoll extends JPanel implements MidiDataListener {
52	public class Key {
53	private boolean disabled = false;
54	private boolean pressed = false;
55	private boolean keyswitch = false;
56
57	public
58	Key() {
59
60	}
61
62	public boolean
63	isDisabled() { return disabled; }
64
65	public void
66	setDisabled(boolean b) { disabled = b; }
67
68	public boolean
69	isPressed() { return pressed; }
70
71	public void
72	setPressed(boolean b) { pressed = b; }
73
74	public boolean
75	isKeyswitch() { return keyswitch; }
76
77	public void
78	setKeyswitch(boolean b) { keyswitch = b; }
79
80	}
81
82
83	private final Vector<Key> keys = new Vector<Key>();
84
85	private boolean vertical;
86	private boolean mirror;
87	private boolean octaveLabelsVisible = true;
88	private boolean playingEnabled = true;
89
90	private int firstKey = -1;
91	private int lastKey = -1;
92	private int whiteKeyCount = 68;
93
94	private Color borderColor = Color.BLACK;
95	private Color keyColor = Color.WHITE;
96	private Color disabledKeyColor = Color.GRAY;
97	private Color pressedKeyColor = Color.GREEN;
98	private Color keySwitchColor = Color.PINK;
99	private Color blackKeyColor = Color.BLACK;
100
101	private final Vector<MidiDataListener> listeners = new Vector<MidiDataListener>();
102
103	private boolean shouldRepaint = false;
104
105	/**
106	* Creates a new horizontal, not mirrored <code>PianoRoll</code>.
107	*/
108	public
109	PianoRoll() { this(false); }
110
111	/**
112	* Creates a new not mirrored <code>PianoRoll</code>.
113	* @param vertical Specifies whether the piano roll
114	* should be vertical or horizontal
115	*/
116	public
117	PianoRoll(boolean vertical) { this(vertical, false); }
118
119	/**
120	* Creates a new instance of <code>PianoRoll</code>.
121	* @param vertical Specifies whether the piano roll
122	* should be vertical or horizontal.
123	* @param mirror Specifies whether to mirror the piano roll.
124	*/
125	public
126	PianoRoll(boolean vertical, boolean mirror) {
127	this.vertical = vertical;
128	this.mirror = mirror;
129
130	this.addMouseListener(getHandler());
131	setKeyRange(0, 127);
132	}
133
134	/**
135	* Registers the specified listener to be notified when
136	* MIDI event occurs due to user input.
137	* @param l The <code>MidiDataListener</code> to register.
138	*/
139	public void
140	addMidiDataListener(MidiDataListener l) { listeners.add(l); }
141
142	/**
143	* Removes the specified listener.
144	* @param l The <code>MidiDataListener</code> to remove.
145	*/
146	public void
147	removeMidiDataListener(MidiDataListener l) { listeners.remove(l); }
148
149	private void
150	fireMidiDataEvent(MidiDataEvent e) {
151	for(MidiDataListener l : listeners) l.midiDataArrived(e);
152	}
153
154	/**
155	* Determines whether the user input is processed
156	* and respective MIDI data events are sent.
157	*/
158	public boolean
159	isPlayingEnabled() { return playingEnabled; }
160
161	/**
162	* Sets whether the user input should be processed
163	* and respective MIDI data events should be sent.
164	* @see #isPlayingEnabled
165	*/
166	public void
167	setPlayingEnabled(boolean b) { playingEnabled = b; }
168
169	public boolean
170	hasKey(int key) {
171	if(key >= firstKey && key <= lastKey) return true;
172	return false;
173	}
174
175	public Key
176	getKey(int key) { return keys.get(key - firstKey); }
177
178	public boolean
179	isKeyDisabled(int key) {
180	return getKey(key).isDisabled();
181	}
182
183	public void
184	setKeyDisabled(int key, boolean disable) {
185	Key k = getKey(key);
186	if(k.isDisabled() == disable) return;
187
188	getKey(key).setDisabled(disable);
189	if(getShouldRepaint()) repaint();
190	}
191
192	public boolean
193	isKeyPressed(int key) {
194	return getKey(key).isPressed();
195	}
196
197	public void
198	setKeyPressed(int key, boolean press) {
199	Key k = getKey(key);
200	if(k.isPressed() == press) return;
201
202	getKey(key).setPressed(press);
203	if(getShouldRepaint()) repaint(getKeyRectangle(key));
204	}
205
206	public boolean
207	isKeyswitch(int key) {
208	return getKey(key).isKeyswitch();
209	}
210
211	public void
212	setKeyswitch(int key, boolean keyswitch) {
213	Key k = getKey(key);
214	if(k.isKeyswitch() == keyswitch) return;
215
216	getKey(key).setKeyswitch(keyswitch);
217	if(getShouldRepaint()) repaint(getKeyRectangle(key));
218	}
219
220	public void
221	setAllKeysPressed(boolean b) {
222	boolean changed = false;
223	for(Key key : keys) {
224	if(key.isPressed() != b) {
225	key.setPressed(b);
226	changed = true;
227	}
228	}
229
230	if(changed && getShouldRepaint()) repaint();
231	}
232
233	public void
234	setAllKeysDisabled(boolean b) {
235	boolean changed = false;
236	for(Key key : keys) {
237	if(key.isDisabled() != b) {
238	key.setDisabled(b);
239	changed = true;
240	}
241	}
242
243	if(changed && getShouldRepaint()) repaint();
244	}
245
246	public Integer[]
247	getKeyswitches() {
248	Vector<Integer> v = new Vector<Integer>();
249	for(int i = 0; i < keys.size(); i++) {
250	if(keys.get(i).isKeyswitch()) v.add(firstKey + i);
251	}
252
253	return v.toArray(new Integer[v.size()]);
254	}
255
256	/**
257	* Keys outside the keyboard range are ignored.
258	* @param keys List of keys
259	*/
260	public void
261	setKeyswitches(Integer[] keys, boolean keyswitches) {
262	boolean changed = false;
263	for(int k : keys) {
264	if(!hasKey(k)) continue;
265	if(getKey(k).isKeyswitch() != keyswitches) {
266	getKey(k).setKeyswitch(keyswitches);
267	changed = true;
268	}
269	}
270	if(changed && getShouldRepaint()) repaint();
271	}
272
273	public Integer[]
274	getEnabledKeys() {
275	Vector<Integer> v = new Vector<Integer>();
276	for(int i = 0; i < keys.size(); i++) {
277	if(!keys.get(i).isDisabled()) v.add(firstKey + i);
278	}
279
280	return v.toArray(new Integer[v.size()]);
281	}
282
283	/**
284	* Enables or disables the specified list of keys.
285	* Keys outside the keyboard range are ignored.
286	* @param keys List of keys
287	*/
288	public void
289	setDisabled(Integer[] keys, boolean disable) {
290	boolean changed = false;
291	for(int k : keys) {
292	if(!hasKey(k)) continue;
293	if(getKey(k).isDisabled() != disable) {
294	getKey(k).setDisabled(disable);
295	changed = true;
296	}
297	}
298	if(changed && getShouldRepaint()) repaint();
299	}
300
301	public void
302	removeAllKeyswitches() {
303	boolean changed = false;
304	for(Key key : keys) {
305	if(key.isKeyswitch()) {
306	key.setKeyswitch(false);
307	changed = true;
308	}
309	}
310	if(changed && getShouldRepaint()) repaint();
311	}
312
313	/**
314	* Sets the piano key range which this piano roll will provide.
315	* Note that the specified last key is also included in the piano roll.
316	* Also, the first and the last key should be white keys. If the first key
317	* and/or the last key are not white keys then the range is extended automatically.
318	* @param firstKey Number between 0 and 127 (inclusive) as specified in the MIDI standard.
319	* @param lastKey Number between 0 and 127 (inclusive) as specified in the MIDI standard.
320	* @throws IllegalArgumentException if the specified range is invalid.
321	*/
322	public void
323	setKeyRange(int firstKey, int lastKey) {
324	if(this.firstKey == firstKey && this.lastKey == lastKey) return;
325
326	if(firstKey < 0 \|\| firstKey > 127 \|\| lastKey < 0 \|\| lastKey > 127 \|\| firstKey >= lastKey) {
327	throw new IllegalArgumentException("Invalid range: " + firstKey + "-" + lastKey);
328	}
329
330	/*Integer[] enabledKeys = getEnabledKeys();
331	Integer[] keyswitches = getKeyswitches();*/
332
333	if(!isWhiteKey(firstKey)) firstKey--;
334	if(!isWhiteKey(lastKey)) lastKey++;
335	this.firstKey = firstKey;
336	this.lastKey = lastKey;
337
338	keys.removeAllElements();
339	for(int i = 0; i <= lastKey - firstKey; i++) keys.add(new Key());
340
341	whiteKeyCount = getWhiteKeyCount(firstKey, lastKey);
342
343	/*setAllKeysDisabled(true);
344	setDisabled(enabledKeys, false);
345	setKeyswitches(keyswitches, true);*/
346
347	if(getShouldRepaint()) repaint();
348	}
349
350	public boolean
351	getOctaveLabelsVisible() {
352	return octaveLabelsVisible;
353	}
354
355	public void
356	setOctaveLabelsVisible(boolean b) {
357	octaveLabelsVisible = b;
358	}
359
360	/**
361	* Gets the number of white keys int the specified range (inclusive).
362	* @see #setKeyRange
363	*/
364	private static int
365	getWhiteKeyCount(int firstKey, int lastKey) {
366	int count = 0;
367	for(int j = firstKey; j <= lastKey; j++) { // FIXME: Stupid but works
368	if(isWhiteKey(j)) count++;
369	}
370
371	return count;
372	}
373
374	private int
375	getWhiteKeyByNumber(int whiteKey) {
376	int count = 0;
377	for(int j = firstKey; j <= lastKey; j++) { // FIXME: Stupid but works
378	if(isWhiteKey(j)) {
379	if(whiteKey == count) return j;
380	count++;
381	}
382	}
383
384	return -1;
385	}
386
387	private int
388	getWhiteKeyCount() {
389	return whiteKeyCount;
390	}
391
392	/**
393	* Determines whether the specified key is a white key.
394	* @param key Number between 0 and 127 (inclusive) as specified in the MIDI standard.
395	*/
396	public static boolean
397	isWhiteKey(int key) {
398	if(key < 0 \|\| key > 127) return false;
399
400	int k = key % 12;
401	if(k == 1 \|\| k == 3 \|\| k == 6 \|\| k == 8 \|\| k == 10) {
402	return false;
403	}
404
405	return true;
406	}
407
408	/**
409	* Returns the position (zero-based) of the specified white key in the octave.
410	* @param whiteKey Number between 0 and 127 (inclusive) as specified in the MIDI standard.
411	* @return Number between 0 and 6 (inclusive) and -1 if the
412	* specified key is not a white key.
413	*/
414	public static int
415	getKeyOctaveIndex(int whiteKey) {
416	if(whiteKey < 0 \|\| whiteKey > 127) return -1;
417
418	int k = whiteKey % 12;
419	if(k == 1 \|\| k == 3 \|\| k == 6 \|\| k == 8 \|\| k == 10) {
420	return -1;
421	}
422
423	return getWhiteKeyCount(0, k) - 1;
424	}
425
426	private Color
427	getKeyColor(int key) {
428	Key k = getKey(key);
429	if(isWhiteKey(key)) {
430	if(k.isPressed()) return pressedKeyColor;
431	if(k.isKeyswitch()) return keySwitchColor;
432	if(k.isDisabled()) return disabledKeyColor;
433	return keyColor;
434	} else {
435	if(k.isPressed()) return Color.GREEN;
436	return blackKeyColor;
437	}
438	}
439
440	/**
441	* Releases all pressed keys, enables all keys and removes all keyswitches.
442	*/
443	public void
444	reset() { reset(false); }
445
446	/**
447	* Releases all pressed keys, enables/disables all keys and removes all keyswitches.
448	* @param dissable Specifies whether all keys should be enabled or disabled
449	*/
450	public void
451	reset(boolean dissableAllKeys) {
452	boolean b = getShouldRepaint();
453	setShouldRepaint(false);
454	setAllKeysPressed(false);
455	removeAllKeyswitches();
456	setAllKeysDisabled(dissableAllKeys);
457	setShouldRepaint(b);
458	if(getShouldRepaint()) repaint();
459	}
460
461	public boolean
462	getShouldRepaint() { return shouldRepaint; }
463
464	public void
465	setShouldRepaint(boolean b) { shouldRepaint = b; }
466
467	private int
468	getKey(Point p) {
469	double w = getWhiteKeyWidth() + /* space between keys */ 1.0d;
470	if(w == 0) return -1;
471	int whiteKeyNumber = (int) (p.getX() / w);
472	double leftBorder = whiteKeyNumber * w;
473	int key = getWhiteKeyByNumber(whiteKeyNumber);
474	if(key == -1) return -1;
475
476	double bh = getBlackKeyHeight();
477	double blackKeyOffset = w / 4.0d;
478	if(p.getY() > bh) return key;
479	if(key != firstKey && !isWhiteKey(key - 1)) {
480	if(p.getX() <= leftBorder + blackKeyOffset) return key - 1;
481	}
482	if(key != lastKey && !isWhiteKey(key + 1)) {
483	if(p.getX() >= leftBorder + 3 * blackKeyOffset - 3) return key + 1;
484	}
485
486	return key;
487	}
488
489	private int
490	getVelocity(Point p, boolean whiteKey) {
491	double h = whiteKey ? getWhiteKeyHeight() : getBlackKeyHeight();
492	int velocity = (int) ((p.getY() / h) * 127.0d + 1);
493	if(velocity < 0) velocity = 0;
494	if(velocity > 127) velocity = 127;
495	return velocity;
496	}
497
498	private double
499	getWhiteKeyWidth() {
500	double w = getSize().getWidth();
501	return (w - getWhiteKeyCount()) / getWhiteKeyCount();
502	}
503
504	private double
505	getWhiteKeyHeight() {
506	return getSize().getHeight() - 3.0d;
507	}
508
509	private double
510	getBlackKeyWidth() {
511	return getWhiteKeyWidth() / 2.0d;
512	}
513
514	private double
515	getBlackKeyHeight() {
516	return getWhiteKeyHeight() / 1.5d;
517	}
518
519	protected void
520	paintOctaveLabel(Graphics2D g, int octave, int whiteKeyIndex) {
521	double h = getSize().getHeight();
522	double whiteKeyWidth = getWhiteKeyWidth();
523	g.setPaint(Color.BLACK);
524	int fsize = (int) (whiteKeyWidth / (1.5 + whiteKeyWidth / 50));
525	if(fsize < 8) fsize = 8;
526	g.setFont(g.getFont().deriveFont(Font.BOLD, fsize));
527
528	float x = (float) (whiteKeyWidth * whiteKeyIndex + whiteKeyIndex);
529	float y = (float) (h - 1);
530
531	String s = String.valueOf(octave);
532	FontMetrics fm = g.getFontMetrics();
533
534	// center text
535	int i = fm.stringWidth(s);
536	if(i < whiteKeyWidth) {
537	x += (whiteKeyWidth - i) / 2;
538	} else {
539	x += 2;
540	}
541
542	y -= (h / 12);
543
544	g.drawString(s, x, y);
545	}
546
547	/**
548	* Gets the rectangle in which the key is drawn and empty rectangle
549	* if the specified key is not shown on the piano roll or is invalid.
550	*/
551	public Rectangle
552	getKeyRectangle(int key) {
553	Rectangle r = new Rectangle();
554	if(!hasKey(key)) return r;
555
556	int whiteKeyIndex = getWhiteKeyCount(firstKey, key) - 1;
557
558	if(isWhiteKey(key)) {
559	double whiteKeyWidth = getWhiteKeyWidth();
560	double whiteKeyHeight = getWhiteKeyHeight();
561	double x = whiteKeyWidth * whiteKeyIndex + whiteKeyIndex;
562	r.setRect(x, 0, whiteKeyWidth, whiteKeyHeight);
563	} else {
564	double blackKeyWidth = getBlackKeyWidth();
565	double blackKeyHeight = getBlackKeyHeight();
566	int i = whiteKeyIndex;
567	double x = blackKeyWidth * (2(i + 1)) - blackKeyWidth 0.5d + i;
568	r.setRect(x, 0, blackKeyWidth, blackKeyHeight);
569	}
570
571	return r;
572	}
573
574	@Override public void
575	paint(Graphics g) {
576	super.paint(g);
577	Graphics2D g2 = (Graphics2D) g;
578
579	double whiteKeyWidth = getWhiteKeyWidth();
580	double whiteKeyHeight = getWhiteKeyHeight();
581	double arcw = whiteKeyWidth/4.0d;
582	double arch = whiteKeyHeight/14.0d;
583
584	g2.setPaint(keyColor);
585
586	RoundRectangle2D.Double rect;
587
588	g2.setRenderingHint (
589	RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF
590	);
591
592	int i = 0;
593	for(int j = firstKey; j <= lastKey; j++) {
594	if(!isWhiteKey(j)) continue;
595
596	Color c = getKeyColor(j);
597	if(g2.getPaint() != c) g2.setPaint(c);
598
599	rect = new RoundRectangle2D.Double (
600	// If you change this you should also change getKeyRectangle()
601	whiteKeyWidth * i + i, 0,
602	whiteKeyWidth, whiteKeyHeight,
603	arcw, arch
604	);
605
606	g2.fill(rect);
607	i++;
608	}
609
610	g2.setRenderingHint (
611	RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON
612	);
613
614	g2.setStroke(new java.awt.BasicStroke(1.5f));
615	g2.setPaint(borderColor);
616
617	i = 0;
618	for(int j = firstKey; j <= lastKey; j++) {
619	if(!isWhiteKey(j)) continue;
620
621	rect = new RoundRectangle2D.Double (
622	whiteKeyWidth * i + i, 0,
623	whiteKeyWidth, whiteKeyHeight,
624	arcw, arch
625	);
626
627	g2.draw(rect);
628	i++;
629	}
630
631
632	g2.setStroke(new java.awt.BasicStroke(2.5f));
633	double blackKeyWidth = getBlackKeyWidth();
634	double blackKeyHeight = getBlackKeyHeight();
635
636	i = 0;
637	for(int j = firstKey; j <= lastKey; j++) {
638	if(getOctaveLabelsVisible() && j % 12 == 0) {
639	int octave = j / 12 - 2;
640	paintOctaveLabel(g2, octave, i);
641	}
642	if(!isWhiteKey(j)) continue;
643
644	int k = (i + getKeyOctaveIndex(firstKey)) % 7;
645	if(k == 2 \|\| k == 6) { i++; continue; }
646
647	Color c = (j == lastKey) ? blackKeyColor : getKeyColor(j + 1);
648	if(g2.getPaint() != c) g2.setPaint(c);
649
650	// If you change this you should also change getKeyRectangle()
651	double x = blackKeyWidth * (2(i + 1)) - blackKeyWidth 0.5d + i;
652	rect = new RoundRectangle2D.Double (
653	// If you change this you should also change getKeyRectangle()
654	x, 0,
655	blackKeyWidth, blackKeyHeight,
656	arcw, arch
657	);
658	///////
659
660	boolean pressed = (j == lastKey) ? false : getKey(j + 1).isPressed();
661	if(!pressed) g2.fill(rect);
662
663	RoundRectangle2D.Double rect2;
664	rect2 = new RoundRectangle2D.Double (
665	x, 0,
666	blackKeyWidth, arch,
667	arcw, arch / 1.8d
668	);
669
670	g2.fill(rect2);
671	g2.setPaint(borderColor);
672	g2.draw(rect);
673
674	if(pressed) {
675	GradientPaint gr = new GradientPaint (
676	(float)(x + blackKeyWidth/2), (float)(blackKeyHeight/4), Color.BLACK,
677	(float)(x + blackKeyWidth/2), (float)blackKeyHeight, new Color(0x058a02)
678	);
679	g2.setPaint(gr);
680	g2.fill(rect);
681	}
682	i++;
683	}
684	}
685
686	@Override public void
687	midiDataArrived(MidiDataEvent e) {
688	switch(e.getType()) {
689	case NOTE_ON:
690	setKeyPressed(e.getNote(), true);
691	break;
692	case NOTE_OFF:
693	setKeyPressed(e.getNote(), false);
694	}
695	}
696
697	private final Handler handler = new Handler();
698
699	private Handler
700	getHandler() { return handler; }
701
702	private class Handler extends MouseAdapter {
703	private int pressedKey = -1;
704
705	@Override public void
706	mousePressed(MouseEvent e) {
707	if(!isPlayingEnabled()) return;
708	if(e.getButton() != MouseEvent.BUTTON1) return;
709
710	int key = getKey(e.getPoint());
711	if(key == -1) return;
712	pressedKey = key;
713	setKeyPressed(key, true);
714	int velocity = getVelocity(e.getPoint(), isWhiteKey(key));
715
716	MidiDataEvent evt = new MidiDataEvent (
717	PianoRoll.this, MidiDataEvent.Type.NOTE_ON, key, velocity
718	);
719
720	fireMidiDataEvent(evt);
721	}
722
723	@Override public void
724	mouseReleased(MouseEvent e) {
725	if(!isPlayingEnabled()) return;
726	if(e.getButton() != MouseEvent.BUTTON1) return;
727
728	if(pressedKey == -1) return;
729	setKeyPressed(pressedKey, false);
730
731	int velocity = getVelocity(e.getPoint(), isWhiteKey(pressedKey));
732	MidiDataEvent evt = new MidiDataEvent (
733	PianoRoll.this, MidiDataEvent.Type.NOTE_OFF, pressedKey, velocity
734	);
735
736	pressedKey = -1;
737
738	fireMidiDataEvent(evt);
739	}
740	}
741	}