#include <slider.h>

Inheritance diagram for Slider:

Public Member Functions
void	setMaxMin (int max, int min=0)

void	setThumbLength (float len)

void	setPageSize (int s)

int	position (void)

void	setPosition (int pos)

void	setThumbColor (const GFXColor &color, const GFXColor &outline)

void	setThumbColorBasedOnColor (const GFXColor &c)

virtual void	draw (void)

virtual void	setRect (const Rect &r)

virtual void	setColor (const GFXColor &c)

virtual bool	processMouseDown (const InputEvent &event)

virtual bool	processMouseUp (const InputEvent &event)

virtual bool	processMouseDrag (const InputEvent &event)

	Slider (void)

virtual	~Slider (void)

Public Member Functions inherited from Control
virtual Rect	rect (void)

virtual bool	hitTest (const Point &p)

virtual bool	hidden (void)

virtual void	setHidden (bool h=true)

virtual const std::string &	id (void)

virtual void	setId (const std::string &newId)

virtual GFXColor	color (void)

virtual GFXColor	outlineColor (void)

virtual void	setOutlineColor (const GFXColor &c)

virtual GFXColor	textColor (void)

virtual void	setTextColor (const GFXColor &c)

virtual Font	font (void)

virtual void	setFont (const Font &f)

virtual bool	hasGroupChildren (void)

	Control (void)

virtual	~Control (void)

Public Member Functions inherited from EventResponder
virtual bool	processCommand (const EventCommandId &command, Control *control)

virtual bool	processKeyDown (const InputEvent &event)

virtual bool	processKeyUp (const InputEvent &event)

virtual void	processUnfocus (const InputEvent &event)

virtual bool	processMouseMove (const InputEvent &event)

virtual void	sendCommand (const EventCommandId &command, Control *control)

virtual void	setCommandTarget (EventResponder *responder)

virtual void	setModal (bool modal)

	EventResponder (void)

virtual	~EventResponder (void)

Protected Types
enum	MouseState { MOUSE_NONE, MOUSE_PAGE_UP, MOUSE_PAGE_DOWN, MOUSE_THUMB_DRAG }

Protected Attributes
int	m_minValue

int	m_maxValue

float	m_thumbLength

float	m_originalThumbLength

int	m_pageSize

GFXColor	m_thumbColor

GFXColor	m_thumbOutlineColor

int	m_position

bool	m_vertical

MouseState	m_mouseState

float	m_buttonDownMouse

int	m_buttonDownPosition

Rect	m_thumbRect

Protected Attributes inherited from Control
Rect	m_rect

std::string	m_id

GFXColor	m_color

GFXColor	m_outlineColor

GFXColor	m_textColor

Font	m_font

bool	m_hidden

Protected Attributes inherited from EventResponder
bool	m_modal

EventResponder *	m_commandTarget

Additional Inherited Members
Protected Member Functions inherited from Control
virtual void	drawBackground (void)

Detailed Description

Definition at line 31 of file slider.h.

Member Enumeration Documentation

enum Slider::MouseState

protected

Enumerator
MOUSE_NONE
MOUSE_PAGE_UP
MOUSE_PAGE_DOWN
MOUSE_THUMB_DRAG

Definition at line 80 of file slider.h.

     {
         MOUSE_NONE,         //Nothing interesting going on.
         MOUSE_PAGE_UP,      //In the middle of a Page Up click.
         MOUSE_PAGE_DOWN,    //In the middle of a Page Down click.
         MOUSE_THUMB_DRAG    //In the middle of dragging the thumb.
     };

Constructor & Destructor Documentation

Slider::Slider ( void )

Definition at line 289 of file slider.cpp.

                      :
     m_minValue( 0 )
     , m_maxValue( 100 )
     , m_thumbLength( .15 )
     , m_originalThumbLength( m_thumbLength )
     , m_pageSize( 10 )
     , m_thumbColor( m_color )
     , m_thumbOutlineColor( GUI_OPAQUE_BLACK() )
     , m_position( m_minValue )
     , m_vertical( true )
     , m_mouseState( MOUSE_NONE )
     , m_buttonDownMouse( 0.0 )
     , m_buttonDownPosition( 0 )
     , m_thumbRect()
 {}

virtual Slider::~Slider ( void )

inlinevirtual

Definition at line 74 of file slider.h.

74 {}

Member Function Documentation

void Slider::draw ( void )

virtual

Implements Control.

Definition at line 156 of file slider.cpp.

References Control::drawBackground(), drawRect(), drawRectOutline(), float, Size::height, Rect::inset(), isClear(), m_maxValue, m_minValue, m_position, Control::m_rect, m_thumbColor, m_thumbLength, m_thumbOutlineColor, m_thumbRect, m_vertical, Rect::origin, Rect::size, Size::width, Point::x, and Point::y.

 {
     //Draw the background.
     drawBackground();
     //Draw the thumb.
     if ( !( isClear( m_thumbColor ) && isClear( m_thumbOutlineColor ) ) ) {
         float relativePosition = 0.0;
         if (m_maxValue != m_minValue)
             relativePosition = ( (float) (m_position-m_minValue) )/(m_maxValue-m_minValue);
         Rect  thumbRect = m_rect;
         if (m_vertical) {
             //Vertical thumb.
             thumbRect.size.height = m_thumbLength*m_rect.size.height;
             thumbRect.origin.y   += (1.0-relativePosition)*(m_rect.size.height-thumbRect.size.height);
         } else {
             //Horizontal thumb.
             thumbRect.size.width = m_thumbLength*m_rect.size.width;
             thumbRect.origin.x  += relativePosition*(m_rect.size.width-thumbRect.size.width);
         }
         m_thumbRect = thumbRect;            //Want to save away the bigger version for mouse hits.
         thumbRect.inset( Size( .01, .01 ) );
         drawRect( thumbRect, m_thumbColor );
         drawRectOutline( thumbRect, m_thumbOutlineColor, 1.0 );
     }
 }

int Slider::position ( void )

inline

Definition at line 48 of file slider.h.

References m_position.

Referenced by Scroller::processCommand(), processMouseDown(), and processMouseUp().

     {
         return m_position;
     }

bool Slider::processMouseDown ( const InputEvent & event)

virtual

Reimplemented from EventResponder.

Definition at line 182 of file slider.cpp.

References InputEvent::code, VegaConfig::getVariable(), globalEventManager(), Control::hitTest(), LEFT_MOUSE_BUTTON, InputEvent::loc, m_buttonDownMouse, m_buttonDownPosition, m_mouseState, m_position, m_thumbLength, m_thumbRect, m_vertical, MOUSE_PAGE_DOWN, MOUSE_PAGE_UP, MOUSE_THUMB_DRAG, NO_THUMB_LENGTH, Rect::origin, XMLSupport::parse_int(), position(), EventResponder::processMouseDown(), EventManager::pushResponder(), Rect::right(), EventResponder::setModal(), setPosition(), Rect::top(), vs_config, WHEELDOWN_MOUSE_BUTTON, WHEELUP_MOUSE_BUTTON, Point::x, and Point::y.

 {
     static int zoominc = XMLSupport::parse_int( vs_config->getVariable( "general", "wheel_increment_lines", "3" ) );
     if ( event.code == LEFT_MOUSE_BUTTON && m_thumbLength != NO_THUMB_LENGTH && hitTest( event.loc ) ) {
         if (m_vertical) {
             if (event.loc.y < m_thumbRect.origin.y) {
                 m_mouseState = MOUSE_PAGE_DOWN;
             } else if ( event.loc.y > m_thumbRect.top() ) {
                 m_mouseState = MOUSE_PAGE_UP;
             } else {
                 m_mouseState = MOUSE_THUMB_DRAG;
                 m_buttonDownMouse = event.loc.y;
                 m_buttonDownPosition = m_position;
             }
         } else {
             if (event.loc.x < m_thumbRect.origin.x) {
                 m_mouseState = MOUSE_PAGE_UP;
             } else if ( event.loc.x > m_thumbRect.right() ) {
                 m_mouseState = MOUSE_PAGE_DOWN;
             } else {
                 m_mouseState = MOUSE_THUMB_DRAG;
                 m_buttonDownMouse = event.loc.x;
                 m_buttonDownPosition = m_position;
             }
         }
         setModal( true );                 //Make sure we don't miss anything.
         //Make sure we see mouse events *first* until we get a mouse-up.
         globalEventManager().pushResponder( this );
         return true;
     } else if (event.code == WHEELUP_MOUSE_BUTTON) {
         if ( hitTest( event.loc ) )
             setPosition( position()-zoominc );
     } else if (event.code == WHEELDOWN_MOUSE_BUTTON) {
         if ( hitTest( event.loc ) )
             setPosition( position()+zoominc );
     }
     return Control::processMouseDown( event );
 }

bool Slider::processMouseDrag ( const InputEvent & event)

virtual

Reimplemented from EventResponder.

Definition at line 221 of file slider.cpp.

References Rect::copyAndInset(), float_to_int(), Size::height, Rect::inside(), InputEvent::loc, m_buttonDownMouse, m_buttonDownPosition, m_maxValue, m_minValue, m_mouseState, Control::m_rect, m_thumbLength, m_vertical, MOUSE_THUMB_DRAG, NO_THUMB_LENGTH, EventResponder::processMouseDrag(), setPosition(), Rect::size, Size::width, Point::x, and Point::y.

 {
     //The interface for mouse dragging is a little weird.  There is no button information.  All
     //we know is that some button is down.  This is enough, since we don't get into a specific
     //mouse state in this control unless we know which mouse button was pressed...
     if (m_mouseState == MOUSE_THUMB_DRAG) {
         if (m_thumbLength == NO_THUMB_LENGTH) return true;
         const Rect cancelRect = m_rect.copyAndInset( THUMB_DRAG_CANCEL_MARGINS );
         if ( !cancelRect.inside( event.loc ) ) {
             //We are outside the cancel rect.  Go back to original position.
             setPosition( m_buttonDownPosition );
             return true;
         } else {
             //We are dragging the thumb -- get a new scroll position.
             if (m_vertical) {
                 //Calculate the factor to convert a change in mouse coords to a change in slider position.
                 //This is derived from the ratio of the non-thumb length in the slider to the
                 //total range.
                 const float totalMouseLength = (1.0-m_thumbLength)*m_rect.size.height;
                 const int   totalRange = m_maxValue-m_minValue;
                 const int   positionChange   = float_to_int( (m_buttonDownMouse-event.loc.y)*totalRange/totalMouseLength+0.5 );
                 setPosition( m_buttonDownPosition+positionChange );
                 return true;
             } else {
                 const float totalMouseLength = (1.0-m_thumbLength)*m_rect.size.width;
                 const int   totalRange = m_maxValue-m_minValue;
                 const int   positionChange   = float_to_int( (event.loc.x-m_buttonDownMouse)*totalRange/totalMouseLength+0.5 );
                 setPosition( m_buttonDownPosition+positionChange );
                 return true;
             }
         }
         return Control::processMouseDrag( event );
     }
     return false;
 }

bool Slider::processMouseUp ( const InputEvent & event)

virtual

Reimplemented from EventResponder.

Definition at line 257 of file slider.cpp.

References InputEvent::code, globalEventManager(), Control::hitTest(), LEFT_MOUSE_BUTTON, InputEvent::loc, m_mouseState, m_pageSize, MOUSE_NONE, MOUSE_PAGE_DOWN, MOUSE_PAGE_UP, MOUSE_THUMB_DRAG, position(), EventResponder::processMouseUp(), EventManager::removeResponder(), EventResponder::setModal(), and setPosition().

 {
     if (m_mouseState != MOUSE_NONE && event.code == LEFT_MOUSE_BUTTON) {
         //We are now done with the modal mouse loop.
         switch (m_mouseState)
         {
         case MOUSE_PAGE_UP:
             if ( hitTest( event.loc ) )
                 setPosition( position()-m_pageSize );
             break;
         case MOUSE_PAGE_DOWN:
             if ( hitTest( event.loc ) )
                 setPosition( position()+m_pageSize );
             break;
         case MOUSE_THUMB_DRAG:
             //Whatever position we have is the correct one.
             //Do nothing.
             break;
         default:
             assert( false );             //Forgot an enum case.
         }
         //Make sure we get off the event chain.
         globalEventManager().removeResponder( this, true );
         setModal( false );
         m_mouseState = MOUSE_NONE;
 
         return Control::processMouseUp( event );
     }
     return false;
 }

void Slider::setColor ( const GFXColor & c)

virtual

Reimplemented from Control.

Definition at line 147 of file slider.cpp.

References Control::setColor(), and setThumbColorBasedOnColor().

Referenced by Scroller::createControls().

 {
     //Calculate a reasonable thumb color.
     setThumbColorBasedOnColor( c );
 
     Control::setColor( c );
 }

void Slider::setMaxMin	(	int	max,
		int	min = `0`
	)

Definition at line 65 of file slider.cpp.

References float_to_int(), m_maxValue, m_minValue, max(), min(), and setPageSize().

Referenced by Scroller::setRangeValues().

 {
     m_maxValue = max;
     m_minValue = min;
 
     //Set default page size
     const int pageSize = float_to_int( (max-min)/10.0+0.5 );
     setPageSize( pageSize );
 }

void Slider::setPageSize ( int s)

inline

Definition at line 41 of file slider.h.

References m_pageSize.

Referenced by setMaxMin(), and Scroller::setRangeValues().

     {
         m_pageSize = s;
     }

void Slider::setPosition ( int pos)

Definition at line 51 of file slider.cpp.

References m_maxValue, m_minValue, m_position, and EventResponder::sendCommand().

Referenced by processMouseDown(), processMouseDrag(), processMouseUp(), and Scroller::setScrollPosition().

 {
     int newPosition = pos;
     if (pos > m_maxValue)
         newPosition = m_maxValue;
     else if (pos < m_minValue)
         newPosition = m_minValue;
     if (m_position != newPosition) {
         m_position = newPosition;
         sendCommand( "Slider::PositionChanged", this );
     }
 }

void Slider::setRect ( const Rect & r)

virtual

Reimplemented from Control.

Definition at line 94 of file slider.cpp.

References Size::height, m_originalThumbLength, Control::m_rect, m_vertical, Control::setRect(), setThumbLength(), Rect::size, and Size::width.

 {
     Control::setRect( r );
 
     //Calculate other things based on new rect.
     m_vertical = (m_rect.size.height >= m_rect.size.width);
     setThumbLength( m_originalThumbLength );
 }

void Slider::setThumbColor	(	const GFXColor &	color,
		const GFXColor &	outline
	)

inline

Definition at line 55 of file slider.h.

References Control::color(), m_thumbColor, and m_thumbOutlineColor.

Referenced by Scroller::setThumbColor(), and setThumbColorBasedOnColor().

     {
         m_thumbColor = color;
         m_thumbOutlineColor = outline;
     }

void Slider::setThumbColorBasedOnColor ( const GFXColor & c)

Definition at line 134 of file slider.cpp.

References darkenColor(), GUI_OPAQUE_WHITE(), isClear(), isColorLight(), lightenColor(), and setThumbColor().

Referenced by Scroller::createControls(), setColor(), and Scroller::setColor().

 {
     if ( !isClear( c ) ) {
         if ( isColorLight( c ) )
             //Light color.  Make thumb darker.
             setThumbColor( darkenColor( c, .3 ), GUI_OPAQUE_WHITE() );
         else
             //Dark Color.
             setThumbColor( lightenColor( c, .3 ), GUI_OPAQUE_WHITE() );
     }
 }

void Slider::setThumbLength ( float len)

Definition at line 76 of file slider.cpp.

References ABSOLUTE_MIN_THUMB_LENGTH, Size::height, m_originalThumbLength, Control::m_rect, m_thumbLength, m_vertical, MAX_THUMB_LENGTH, MIN_THUMB_LENGTH, NO_THUMB_LENGTH, Rect::size, and Size::width.

Referenced by Scroller::setRangeValues(), and setRect().

 {
     float realLen = m_originalThumbLength = len;
     if (realLen > MAX_THUMB_LENGTH || realLen < 0.0)
         realLen = NO_THUMB_LENGTH;
     else if (realLen < MIN_THUMB_LENGTH)
         realLen = MIN_THUMB_LENGTH;
     //Make sure the thumb is at least an absolute size.
     if (m_vertical) {
         if (realLen*m_rect.size.height < ABSOLUTE_MIN_THUMB_LENGTH && m_rect.size.height > 0)
             realLen = ABSOLUTE_MIN_THUMB_LENGTH/m_rect.size.height;
     } else if (realLen*m_rect.size.width < ABSOLUTE_MIN_THUMB_LENGTH && m_rect.size.height > 0) {
         realLen = ABSOLUTE_MIN_THUMB_LENGTH/m_rect.size.width;
     }
     m_thumbLength = realLen;
 }