/*
    * Copyright (c) 2006 Stiftung Deutsches Elektronen-Synchroton,
    * Member of the Helmholtz Association, (DESY), HAMBURG, GERMANY.
    *
    * THIS SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN "../AS IS" BASIS.
    * WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
    * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR PARTICULAR PURPOSE AND
    * NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
    * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
   * THE USE OR OTHER DEALINGS IN THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE
   * IN ANY RESPECT, THE USER ASSUMES THE COST OF ANY NECESSARY SERVICING, REPAIR OR
   * CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE.
   * NO USE OF ANY SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
   * DESY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
   * OR MODIFICATIONS.
   * THE FULL LICENSE SPECIFYING FOR THE SOFTWARE THE REDISTRIBUTION, MODIFICATION,
   * USAGE AND OTHER RIGHTS AND OBLIGATIONS IS INCLUDED WITH THE DISTRIBUTION OF THIS
   * PROJECT IN THE FILE LICENSE.HTML. IF THE LICENSE IS NOT INCLUDED YOU MAY FIND A COPY
   * AT HTTP://WWW.DESY.DE/LEGAL/LICENSE.HTM
   */
  
  package de.desy.acop.demo.example;
  
  import java.awt.Color;
  import java.beans.PropertyVetoException;
  
  import com.cosylab.gui.adapters.Converter;
  import com.cosylab.gui.adapters.ConverterChain;
  import com.cosylab.gui.adapters.LinearConverter;
  import com.cosylab.gui.adapters.LogarithmicConverter;
  import com.cosylab.gui.components.SliderSetMode;
  import com.cosylab.gui.components.Slider.Button;
  import com.cosylab.gui.components.util.IconHelper;
  import com.cosylab.util.CommonException;
  
  import de.desy.acop.displayers.AcopSlider;
  import de.desy.acop.transport.AccessMode;
  import de.desy.acop.transport.ConnectionParameters;
  
  public class SliderExample {
  
  	public static void main(String[] args) {
  		
  		//How to connect slider to a remote property?
  		//First we create an instance of the AcopSlider object.
  		AcopSlider slider = new AcopSlider();
  		//We require ConnectionParameters which describe the remote property
  		ConnectionParameters parameters = new ConnectionParameters("TINE",
  				"context", "server", "device", "property", AccessMode.POLL, 1000);
  		//These parameters describe a remote property 'context/server/device/property'
  		//in the TINE control system. We will request a constant monitoring,
  		//therefore AccessMode.POLL was used. Polling rate is set to 1000 milliseconds,
  		//which means that value on the slider will be updated every 1000 milliseconds.
  		//Parameters are then attached to the slider. Connection is created automatically.
  		try {
  			slider.setConnectionParameters(parameters);
  		} catch (CommonException e) {
  			e.printStackTrace();
  		} catch (PropertyVetoException e) {
  			e.printStackTrace();
  		}
  		//If no exception occurred, slider should show the remote value.
  		
  		
  		//The slider will set the value on the property each time when a user 
  		//drags the slider thumb. We want to avoid the overload and only change the
  		//value when one releases the thumb. 
  		slider.setSetMode(SliderSetMode.SET_ON_RELEASE);
  		//Or we can use a set button to send values. In this case a value will be
  		//sent only after the set button will be pressed. The current thumb position will
  		//be set.
  		slider.setSetMode(SliderSetMode.SET_MANUAL);
  		
  		
  		//The navigation buttons are moving thumb in too small steps. We want to change
  		//the '+' button command to change the value for 2% of the total slider extent
  		//If (slider max - slider min = 500) then 2% of this is 10.
  		slider.setBitStepRelative(true);
  		slider.setBitStep(2.0);
  		//Or we want to explicitly define that the thumb should move for 11 points
  		//when the button is pressed
  		slider.setBitStepRelative(false);
  		slider.setBitStep(11);
  		//Similarly we can program the the 'forward' and 'fastForward' buttons. We want
  		//the forward button to move the thumb for 32.1 units and the fast forward for
  		//53.8 units
  		slider.setSmallStepRelative(false);
  		slider.setSmallStep(32.1);
  		slider.setLargeStepRelative(false);
  		slider.setLargeStep(53.8);
  		
  		//The incoming values are too large (large exponents) and have a large extent.
  		//We want to show values in more readable form. Let us show the logarithm of
  		//the value. For this we will use a logarithmic converter with logarithm base 10:
  		LogarithmicConverter logConverter = new LogarithmicConverter(10);
  		try {
  			slider.setConverter(logConverter);
  		} catch (PropertyVetoException e) {
 			e.printStackTrace();
 		}
 		//Instead of real value 'x' slider will now show log_10(x).
 		//Similarly we can shift the values to be comparable with some other property.
 		//We will use linear converter:
 		LinearConverter linConverter = new LinearConverter(5,4);
 		try {
 			slider.setConverter(linConverter);
 		} catch (PropertyVetoException e) {
 			e.printStackTrace();
 		}
 		//Instead of value 'x' slider will now show 5 x + 4. We can even combine both 
 		//converters into a single one.
 		try {
 			ConverterChain chain = new ConverterChain(new Converter[]{logConverter, linConverter});
 			slider.setConverter(chain);
 		} catch (PropertyVetoException e) {
 			e.printStackTrace();
 		}
 		//Slider will now show 5 (log_10(x)) + 4.
 		
 		//If slider is used to show a value that changes because of a 3rd party, 
 		//we don't want the slider thumb to be out of sync each time the value
 		//changes, but want the thumb to move together with the slider. We will
 		//set the automatic synchronization with 5 seconds time
 		slider.setAutoSynchronize(true);
 		slider.setAutoSynchronizeDelay(5000);
 		//or if we don't want to change the values at all (just use the slider
 		//as a monitor displayer) we can put slider in read only mode
 		slider.setEditable(false);
 		//Or we can set slider to use only one thumb to present a value. In this
 		//case the trailer shadow will not be painted. The thumb of the slider can
 		//be dragged to any position and that value will be set on the slider. 
 		//However, when response is received from the connection point, the thumb
 		//will move to the actual value of the property.
 		slider.setSyncButtonVisible(false);
 		
 		//Let's say that we have good settings on the properties, but would like to
 		//fine tune it. However, if tuning produces worse results than the current
 		//state of the machine we want to restore the value. First we have to
 		//store the value. This can be done in two way: one can store the current
 		//slider readback value 
 		slider.storeValue();
 		//or explicitely define a value
 		slider.setStoredValue(100.);
 		//At any later time we can restore the value to the last stored value
 		slider.restoreValue();
 		//We can also enable store and restore buttons which can be used in runtime
 		//to store or restore the value. The store button will always store current
 		//readback value.
 		slider.setStorageButtonsVisible(true);
 		
 		//Slider will display ticks along the slider line according to the space
 		//available. If one is not satisfied with automatic tick configurations,
 		//ticks can be explicitely defined. First we have to provide which values
 		//will be marked as major ticks
 		slider.setMajorTicks(new double[]{0,20,40,60,80,100});
 		//Then we define which of these major ticks will have value labels printed
 		slider.setMajorTickLabels(new double[]{0,40,60,100});
 		//At last we define, the step of the minor ticks (distance between two minor
 		//ticks)
 		slider.setMinorTicksStep(5);
 		
 		//Slider can operate in continuous mode, meaning that on button press 
 		//and hold, value will be automatically incremented/decremented 
 		//accordig to the step defined by which button is used.
 		//ContinuousModeDelayTime time defines the initial delay time in 
 		//milliseconds between button press and	first automatic repetition.
 		//ContinuousModeRepeatTime defines the time interval in milliseconds 
 		//between two repetitions.
 		//If ContinuousControlVisible is set to false, user will not be able 
 		//to engage or disengage auto incrementation/decremtnation, but the 
 		//mode of operation will remain.
 
 		slider.setContinuousModeDelayTime(1000);
 		slider.setContinuousModeRepeatTime(100);
 
 		slider.setContinuousModeEnabled(true);
 		slider.setContinuousControlVisible(true);
 		
 		//When setting the value on the slider, the position of the slider will
 		//show the exact value as set by the data source or through UI, even if
 		//the provided value does not fall to the tick printed on the slider.
 		//If one want the slider to snap to the tick value, snap to ticks option
 		//can be switched on.
 		slider.setSnapToTicks(true);
 
 		//TooltipText
 		//String provided will be set as tooltip text to the surrounding 
 		//area not regarding button and other similar control components.
 		slider.setToolTipText("Value");
 
 		//Button icons
 		//Navigation button icons can be changed, by supplying the button 
 		//enumeration and Icon object.
 		slider.setButtonIcon(Button.BIT_DECREMENT, IconHelper.createIcon("icons/navigation/ArrowLeft16.gif"));
 	
 		//Button text
 		//Navigation button text can be changed or added, by supplying the 
 		//button enumeration and string containing the desired text.
 			
 		slider.setButtonText(Button.BIT_DECREMENT, "Bit decrement");
 
 		//Other properties of the slider can also simply be adjusted by calling the
 		//appropriate setter methods. These properties include maximum/minimum value
 		//background/foreground color, title etc.:
 		slider.setMaximum(100);
 		slider.setMinimum(5.2);
 		slider.setBackground(Color.RED);
 		slider.setForeground(Color.GREEN);
 	}
 }