controlp5/controlP5/Slider.java

649 lines
18 KiB
Java
Executable File

package main.java.src2.main.java.controlP5.controlP5;
/**
* controlP5 is a processing gui library.
*
* 2006-2015 by Andreas Schlegel
*
* 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.
* 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., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA
*
* @author Andreas Schlegel (http://www.sojamo.de)
* @modified ##date##
* @version ##version##
*
*/
import java.util.ArrayList;
import processing.core.PApplet;
import processing.core.PGraphics;
/**
* A slider is either used horizontally or vertically. when adding a slider to controlP5, the width
* is compared against the height. if the width is bigger, you get a horizontal slider, is the
* height bigger, you get a vertical slider. a slider can have a fixed slider handle (one end of the
* slider is fixed to the left or bottom side of the controller), or a flexible slider handle (a
* handle you can drag).
*
*
* @example controllers/ControlP5slider
*/
public class Slider extends Controller< Slider > {
public final static int FIX = 1;
public final static int FLEXIBLE = 0;
protected int _mySliderMode = FIX;
protected float _myValuePosition;
protected int _myHandleSize = 0;
protected int _myDefaultHandleSize = 10;
protected int triggerId = PRESSED;
protected ArrayList< TickMark > _myTickMarks = new ArrayList< TickMark >( );
protected boolean isShowTickMarks;
protected boolean isSnapToTickMarks;
protected static int autoWidth = 99;
protected static int autoHeight = 9;
protected float scrollSensitivity = 0.1f;
protected int _myColorTickMark = 0xffffffff;
private SliderView _myView;
protected float _myMinReal = 0;
protected float _myMaxReal = 1;
protected float _myInternalValue = 0;
/**
* Convenience constructor to extend Slider.
*
* @example use/ControlP5extendController
* @param theControlP5
* @param theName
*/
public Slider( ControlP5 theControlP5 , String theName ) {
this( theControlP5 , theControlP5.getDefaultTab( ) , theName , 0 , 100 , 0 , 0 , 0 , autoWidth , autoHeight );
theControlP5.register( theControlP5.papplet , theName , this );
}
public Slider( ControlP5 theControlP5 , ControllerGroup< ? > theParent , String theName , float theMin , float theMax , float theDefaultValue , int theX , int theY , int theWidth , int theHeight ) {
super( theControlP5 , theParent , theName , theX , theY , theWidth , theHeight );
_myMin = 0;
_myMax = 1;
// with _myMinReal and _myMaxReal the range of values can now range
// from big to small (e.g. 255 to 0) as well as from small to big (e.g. 0 to 255)
_myMinReal = theMin;
_myMaxReal = theMax;
_myValue = PApplet.map( theDefaultValue , _myMinReal , _myMaxReal , 0 , 1 );
_myCaptionLabel = new Label( cp5 , theName ).setColor( color.getCaptionLabel( ) );
_myValueLabel = new Label( cp5 , String.valueOf(getValue())).setColor( color.getValueLabel( ) );
setSliderMode( FIX );
}
@ControlP5.Invisible @Override public void init( ) {
// need to override init here since _myValue will only be a
// normalized value here but _myDefaultValue needs to be absolute.
// by normalizing _myValue the range of values can be from 'big-to-small'
// as well as from 'small-to-big'
// in order not to break anything, init() will be overwritten here.
_myDefaultValue = getValue( );
cp5.getControlBroadcaster( ).plug( cp5.papplet , this , _myName );
initControllerValue( );
isInit = cp5.isAutoInitialization;
setValue( _myDefaultValue );
isInit = true;
updateDisplayMode( DEFAULT );
}
/**
* use the slider mode to set the mode of the slider bar, which can be Slider.FLEXIBLE or
* Slider.FIX
*
* @param theMode
* int
*/
public Slider setSliderMode( int theMode ) {
_myView = ( getWidth( ) > getHeight( ) ) ? new SliderViewH( ) : new SliderViewV( );
_myControllerView = ( getWidth( ) > getHeight( ) ) ? new SliderViewH( ) : new SliderViewV( );
_mySliderMode = theMode;
if ( _mySliderMode == FLEXIBLE ) {
_myHandleSize = ( _myDefaultHandleSize >= getHeight( ) / 2 ) ? _myDefaultHandleSize / 2 : _myDefaultHandleSize;
} else {
_myHandleSize = 0;
}
_myView.updateUnit( );
setValue( PApplet.map( _myValue , 0 , 1 , _myMinReal , _myMaxReal ) );
return this;
}
public int getSliderMode( ) {
return _mySliderMode;
}
/**
* sets the size of the Slider handle, by default it is set to either the width or height of the
* slider.
*
* @param theSize
*/
public Slider setHandleSize( int theSize ) {
_myDefaultHandleSize = theSize;
setSliderMode( _mySliderMode );
return this;
}
public int getHandleSize( ) {
return _myHandleSize;
}
/**
* @see ControllerInterface.updateInternalEvents
*
*/
@ControlP5.Invisible public Slider updateInternalEvents( PApplet theApplet ) {
if ( isVisible ) {
if ( isMousePressed && !cp5.isAltDown( ) ) {
_myView.updateInternalEvents( theApplet );
}
}
return this;
}
/**
* the trigger event is set to Slider.PRESSED by default but can be changed to Slider.RELEASE so
* that events are triggered when the slider is released.
*
* @param theEventID
*/
public Slider setTriggerEvent( int theEventID ) {
triggerId = theEventID;
return this;
}
/**
* returns the current trigger event which is either Slider.PRESSED or Slider.RELEASE
*
* @return int
*/
public int getTriggerEvent( ) {
return triggerId;
}
@Override protected void mouseReleasedOutside( ) {
mouseReleased( );
}
@Override protected void mouseReleased( ) {
if ( triggerId == RELEASE ) {
_myView.update( );
broadcast( FLOAT );
}
}
protected Slider snapValue( float theValue ) {
if ( isSnapToTickMarks ) {
_myValuePosition = ( ( _myValue - _myMin ) / _myUnit );
_myView.setSnapValue( );
}
return this;
}
public float getValuePosition( ) {
return _myValuePosition;
}
/**
* set the value of the slider.
*
* @param theValue
* float
*/
@Override public Slider setValue( float theValue ) {
if ( isMousePressed && theValue == getValue( ) ) {
return this;
}
_myInternalValue = theValue;
_myValue = PApplet.map( theValue , _myMinReal , _myMaxReal , 0 , 1 );
snapValue( _myValue );
_myValue = ( _myValue <= _myMin ) ? _myMin : _myValue;
_myValue = ( _myValue >= _myMax ) ? _myMax : _myValue;
_myValuePosition = ( ( _myValue - _myMin ) / _myUnit );
_myValueLabel.set( adjustValue( getValue( ) ) );
if ( triggerId == PRESSED ) {
broadcast( FLOAT );
}
return this;
}
@Override public float getValue( ) {
return PApplet.map( _myValue , 0 , 1 , _myMinReal , _myMaxReal );
}
/**
* assigns a random value to the slider.
*/
public Slider shuffle( ) {
float r = ( float ) Math.random( );
setValue( PApplet.map( r , 0 , 1 , _myMinReal , _myMaxReal ) );
return this;
}
/**
* sets the sensitivity for the scroll behavior when using the mouse wheel or the scroll
* function of a multi-touch track pad. The smaller the value (closer to 0) the higher the
* sensitivity. by default this value is set to 0.1
*
* @param theValue
* @return Slider
*/
public Slider setScrollSensitivity( float theValue ) {
scrollSensitivity = theValue;
return this;
}
/**
* changes the value of the slider when hovering and using the mouse wheel or the scroll
* function of a multi-touch track pad.
*
* @param theRotationValue
* @return Slider
*/
@ControlP5.Invisible public Slider scrolled( int theRotationValue ) {
if ( isVisible ) {
float f = _myValue;
float steps = isSnapToTickMarks ? ( 1.0f / getNumberOfTickMarks( ) ) : scrollSensitivity * 0.1f;
f += ( _myMax - _myMin ) * ( -theRotationValue * steps );
setValue( PApplet.map( f , 0 , 1 , _myMinReal , _myMaxReal ) );
if ( triggerId == RELEASE ) {
broadcast( FLOAT );
}
}
return this;
}
@Override public Slider update( ) {
return setValue( PApplet.map( _myValue , 0 , 1 , _myMinReal , _myMaxReal ) );
}
/**
* sets the minimum value of the slider.
*
* @param theValue
* float
*/
@Override public Slider setMin( float theValue ) {
float f = getValue( );
_myMinReal = theValue;
_myValue = PApplet.map( f , _myMinReal , _myMaxReal , 0 , 1 );
setSliderMode( _mySliderMode );
return this;
}
/**
* set the maximum value of the slider.
*
* @param theValue
* float
*/
@Override public Slider setMax( float theValue ) {
float f = getValue( );
_myMaxReal = theValue;
_myValue = PApplet.map( f , _myMinReal , _myMaxReal , 0 , 1 );
setSliderMode( _mySliderMode );
return this;
}
@Override public float getMin( ) {
return _myMinReal;
}
@Override public float getMax( ) {
return _myMaxReal;
}
public Slider setRange( float theMin , float theMax ) {
float f = _myInternalValue;
_myMinReal = theMin;
_myMaxReal = theMax;
_myValue = PApplet.map( f , _myMinReal , _myMaxReal , 0 , 1 );
setSliderMode( _mySliderMode );
return this;
}
/**
* set the width of the slider.
*
* @param theValue
* int
*/
@Override public Slider setWidth( int theValue ) {
super.setWidth( theValue );
setSliderMode( _mySliderMode );
return this;
}
/**
* set the height of the slider.
*
* @param theValue
* int
*/
@Override public Slider setHeight( int theValue ) {
super.setHeight( theValue );
setSliderMode( _mySliderMode );
return this;
}
@Override public Slider setSize( int theWidth , int theHeight ) {
super.setWidth( theWidth );
setHeight( theHeight );
_myView = ( getWidth( ) > getHeight( ) ) ? new SliderViewH( ) : new SliderViewV( );
return this;
}
/* TODO new implementations follow: http://www.ibm.com/developerworks/java/library/j-dynui/ take
* interface builder as reference */
protected Slider setTickMarks( ) {
return this;
}
/**
* sets the number of tickmarks for a slider, by default tick marks are turned off.
*
* @param theNumber
*/
public Slider setNumberOfTickMarks( int theNumber ) {
_myTickMarks.clear( );
if ( theNumber > 0 ) {
for ( int i = 0 ; i < theNumber ; i++ ) {
_myTickMarks.add( new TickMark( this ) );
}
showTickMarks( true );
snapToTickMarks( true );
setHandleSize( 20 );
} else {
showTickMarks( false );
snapToTickMarks( false );
setHandleSize( _myDefaultHandleSize );
}
setValue( PApplet.map( _myValue , 0 , 1 , _myMinReal , _myMaxReal ) );
return this;
}
/**
* returns the amount of tickmarks available for a slider
*
* @return int
*/
public int getNumberOfTickMarks( ) {
return _myTickMarks.size( );
}
/**
* shows or hides tickmarks for a slider
*
* @param theFlag
* @return Slider
*/
public Slider showTickMarks( boolean theFlag ) {
isShowTickMarks = theFlag;
return this;
}
/**
* enables or disables snap to tick marks.
*
* @param theFlag
* @return Slider
*/
public Slider snapToTickMarks( boolean theFlag ) {
isSnapToTickMarks = theFlag;
return this;
}
/**
* returns an instance of a tickmark by index.
*
* @see TickMark
* @param theIndex
* @return
*/
public TickMark getTickMark( int theIndex ) {
if ( theIndex >= 0 && theIndex < _myTickMarks.size( ) ) {
return _myTickMarks.get( theIndex );
} else {
return null;
}
}
/**
* returns an ArrayList of available tick marks for a slider.
*
* @return ArrayList<TickMark>
*/
public ArrayList< TickMark > getTickMarks( ) {
return _myTickMarks;
}
/**
* {@inheritDoc}
*/
@Override @ControlP5.Invisible public Slider linebreak( ) {
cp5.linebreak( this , true , autoWidth , autoHeight , autoSpacing );
return this;
}
/**
* sets the color of tick marks if enabled. by default the color is set to white.
*
* @param theColor
* @return Slider
*/
public Slider setColorTickMark( int theColor ) {
_myColorTickMark = theColor;
return this;
}
public int getDirection( ) {
return ( _myView instanceof SliderViewH ) ? HORIZONTAL : VERTICAL;
}
/**
* {@inheritDoc}
*/
@Override @ControlP5.Invisible public Slider updateDisplayMode( int theMode ) {
_myDisplayMode = theMode;
switch ( theMode ) {
case ( DEFAULT ):
_myControllerView = ( getWidth( ) > getHeight( ) ) ? new SliderViewH( ) : new SliderViewV( );
break;
case ( IMAGE ):
// TODO
break;
case ( SPRITE ):
// TODO
break;
case ( CUSTOM ):
default:
break;
}
return this;
}
private abstract class SliderView implements ControllerView< Slider > {
abstract void updateInternalEvents( PApplet theApplet );
abstract void update( );
abstract void updateUnit( );
abstract void setSnapValue( );
}
private class SliderViewV extends SliderView {
SliderViewV( ) {
_myCaptionLabel.align( LEFT , BOTTOM_OUTSIDE ).setPadding( 0 , Label.paddingY );
_myValueLabel.set(adjustValue(getValue())).align( RIGHT_OUTSIDE , TOP );
}
void setSnapValue( ) {
float n = PApplet.round( PApplet.map( _myValuePosition , 0 , getHeight( ) , 0 , _myTickMarks.size( ) - 1 ) );
_myValue = PApplet.map( n , 0 , _myTickMarks.size( ) - 1 , _myMin , _myMax );
}
void updateUnit( ) {
_myUnit = ( _myMax - _myMin ) / ( getHeight( ) - _myHandleSize );
}
void update( ) {
float f = _myMin + ( - ( _myControlWindow.mouseY - ( y( _myParent.getAbsolutePosition( ) ) + y( position ) ) - getHeight( ) ) ) * _myUnit;
setValue( PApplet.map( f , 0 , 1 , _myMinReal , _myMaxReal ) );
}
void updateInternalEvents( PApplet theApplet ) {
float f = _myMin + ( - ( _myControlWindow.mouseY - ( y( _myParent.getAbsolutePosition( ) ) + y( position ) ) - getHeight( ) ) ) * _myUnit;
setValue( PApplet.map( f , 0 , 1 , _myMinReal , _myMaxReal ) );
}
public void display( PGraphics theGraphics , Slider theController ) {
theGraphics.fill( getColor( ).getBackground( ) );
theGraphics.noStroke( );
if ( ( getColor( ).getBackground( ) >> 24 & 0xff ) > 0 ) {
theGraphics.rect( 0 , 0 , getWidth( ) , getHeight( ) );
}
theGraphics.fill( getIsInside( ) ? getColor( ).getActive( ) : getColor( ).getForeground( ) );
if ( getSliderMode( ) == FIX ) {
theGraphics.rect( 0 , getHeight( ) , getWidth( ) , -getValuePosition( ) );
} else {
if ( isShowTickMarks ) {
theGraphics.triangle( getWidth( ) , getHeight( ) - getValuePosition( ) , getWidth( ) , getHeight( ) - getValuePosition( ) - getHandleSize( ) , 0 , getHeight( ) - getValuePosition( ) - getHandleSize( ) / 2 );
} else {
theGraphics.rect( 0 , getHeight( ) - getValuePosition( ) - getHandleSize( ) , getWidth( ) , getHandleSize( ) );
}
}
if ( isLabelVisible ) {
getCaptionLabel( ).draw( theGraphics , 0 , 0 , theController );
theGraphics.pushMatrix( );
theGraphics.translate( 0 , ( int ) PApplet.map( _myValue , _myMax , _myMin , 0 , getHeight( ) - _myValueLabel.getHeight( ) ) );
getValueLabel( ).draw( theGraphics , 0 , 0 , theController );
theGraphics.popMatrix( );
}
if ( isShowTickMarks ) {
theGraphics.pushMatrix( );
theGraphics.pushStyle( );
theGraphics.translate( -4 , ( getSliderMode( ) == FIX ) ? 0 : getHandleSize( ) / 2 );
theGraphics.fill( _myColorTickMark );
float x = ( getHeight( ) - ( ( getSliderMode( ) == FIX ) ? 0 : getHandleSize( ) ) ) / ( getTickMarks( ).size( ) - 1 );
for ( TickMark tm : getTickMarks( ) ) {
tm.draw( theGraphics , getDirection( ) );
theGraphics.translate( 0 , x );
}
theGraphics.popStyle( );
theGraphics.popMatrix( );
}
}
}
private class SliderViewH extends SliderView {
SliderViewH( ) {
_myCaptionLabel.align( RIGHT_OUTSIDE , CENTER );
_myValueLabel.set(adjustValue(getValue())).align( LEFT , CENTER );
}
void setSnapValue( ) {
float n = PApplet.round( PApplet.map( _myValuePosition , 0 , getWidth( ) , 0 , _myTickMarks.size( ) - 1 ) );
_myValue = PApplet.map( n , 0 , _myTickMarks.size( ) - 1 , _myMin , _myMax );
}
void updateUnit( ) {
_myUnit = ( _myMax - _myMin ) / ( getWidth( ) - _myHandleSize );
}
void update( ) {
float f = _myMin + ( _myControlWindow.mouseX - ( x( _myParent.getAbsolutePosition( ) ) + x( position ) ) ) * _myUnit;
setValue( PApplet.map( f , 0 , 1 , _myMinReal , _myMaxReal ) );
}
void updateInternalEvents( PApplet theApplet ) {
float f = _myMin + ( _myControlWindow.mouseX - ( x( _myParent.getAbsolutePosition( ) ) + x( position ) ) ) * _myUnit;
setValue( PApplet.map( f , 0 , 1 , _myMinReal , _myMaxReal ) );
}
public void display( PGraphics theGraphics , Slider theController ) {
theGraphics.fill( getColor( ).getBackground( ) );
theGraphics.noStroke( );
if ( ( getColor( ).getBackground( ) >> 24 & 0xff ) > 0 ) {
theGraphics.rect( 0 , 0 , getWidth( ) , getHeight( ) );
}
theGraphics.fill( getIsInside( ) ? getColor( ).getActive( ) : getColor( ).getForeground( ) );
if ( getSliderMode( ) == FIX ) {
theGraphics.rect( 0 , 0 , getValuePosition( ) , getHeight( ) );
} else {
if ( isShowTickMarks ) {
theGraphics.triangle( getValuePosition( ) , 0 , getValuePosition( ) + getHandleSize( ) , 0 , getValuePosition( ) + _myHandleSize / 2 , getHeight( ) );
} else {
theGraphics.rect( getValuePosition( ) , 0 , getHandleSize( ) , getHeight( ) );
}
}
theGraphics.fill( 255 );
if ( isLabelVisible ) {
getValueLabel( ).draw( theGraphics , 0 , 0 , theController );
getCaptionLabel( ).draw( theGraphics , 0 , 0 , theController );
}
if ( isShowTickMarks ) {
theGraphics.pushMatrix( );
// theGraphics.pushStyle( );
theGraphics.translate( ( getSliderMode( ) == FIX ) ? 0 : getHandleSize( ) / 2 , getHeight( ) );
theGraphics.fill( _myColorTickMark );
theGraphics.noStroke( );
float x = ( getWidth( ) - ( ( getSliderMode( ) == FIX ) ? 0 : getHandleSize( ) ) ) / ( getTickMarks( ).size( ) - 1 );
for ( TickMark tm : getTickMarks( ) ) {
tm.draw( theGraphics , getDirection( ) );
theGraphics.translate( x , 0 );
}
// theGraphics.popStyle( );
theGraphics.popMatrix( );
}
}
}
@Deprecated public void setSliderBarSize( int theSize ) {
_myDefaultHandleSize = theSize;
setSliderMode( _mySliderMode );
}
/**
* @see Slider#setScrollSensitivity(float)
*
* @param theValue
* @return Slider
*/
@Deprecated public Slider setSensitivity( float theValue ) {
return setScrollSensitivity( theValue );
}
}