slider.hpp

Go to the documentation of this file.

#ifndef __SLIDER__
#define __SLIDER__

#include <tucano/shapes/quad.hpp>
#include <tucano/gui/element.hpp>
#include <Eigen/Dense>

namespace Tucano
{

namespace GUI
{

class Slider : public Element {

protected:

    Tucano::Texture slider_texture;

    function< void(float) > callback;

    float value = 0.5;

    float min_value = 0.0;
    float max_value = 1.0;

    Eigen::Affine3f slider_model_matrix = Eigen::Affine3f::Identity();

    bool sliding = false;

    Eigen::Vector2i slider_pos = Eigen::Vector2i::Zero();

    Eigen::Vector2i slider_dim = Eigen::Vector2i::Zero();

public:

    Slider (void)
    {
        Slider(10, 100, 0, 0);
    }

    Slider (int w, int h, int x, int y)
    {
        dimensions << w, h;
        position << x, y;
        setValue(value);
        element_type = Tucano::GUI::SLIDER;
        num_params = 1;
    }

    Slider (int w, int h, int x, int y, string bar_tex, string slider_tex)
    {
        Slider (w, h, x, y);
        setTexture (bar_tex, slider_tex);
    }

    void setMinMaxValues (float minv, float maxv)
    {
        min_value = minv;
        max_value = maxv;
    }


    void moveSlider (float v)
    {
        setValue ((v - min_value)/(max_value - min_value));    
    }

    void setValue (float normalized_pos)
    {
         // clamp in range [0,1]
        value = min( max (0.0f, normalized_pos), 1.0f);
        slider_pos << position[0] + dimensions[0]*value, position[1];
        setSliderModelMatrix();
    }

    bool isInside (const Eigen::Vector2i& pos)
    {
        // check if clicked on bar
        if (Tucano::GUI::Element::isInside(pos))
        {
            float relative_pos = (pos[0] - position[0])/(float)dimensions[0];
            // check if clicked on slider handle, we leave an extra margin to facilita clicking
            if (fabs(relative_pos - value) <= 1.5*slider_dim[0]/(float)dimensions[0]) 
            { 
                setValue(relative_pos);
                sliding = true;
            }
            return true;
        }
        sliding = false;
        return false;
    }

    void cursorMove (int x, int y)
    {
        if (sliding)
        {
            setValue((x - position[0])/(float)dimensions[0]);
        }
    }


    void release (void)
    {
        sliding = false;
    }


    int getType (void)
    {
        return Tucano::GUI::SLIDER;
    }

    void setTexture (string bar_file, string slider_file)
    {
        Tucano::ImageImporter::loadImage(bar_file, &texture);
        texture.setTexParameters( GL_REPEAT, GL_REPEAT, GL_LINEAR, GL_LINEAR );
        Tucano::ImageImporter::loadImage(slider_file, &slider_texture);
        slider_texture.setTexParameters( GL_REPEAT, GL_REPEAT, GL_LINEAR, GL_LINEAR );

        slider_dim << slider_texture.getWidth() * (dimensions[1] / (float) texture.getHeight()), dimensions[1];

        setValue(value);
    }

    void onValueChanged (function<void(float)> f)
    {
        callback = f;  
    }


    float getValue (void)
    {
        return (value)*(max_value-min_value) + min_value;
    }


    void valueChanged (void)
    {
        callback(getValue());
    }

    void setColor (const Eigen::Vector4f& c)
    {
        color = c;
    }

    void setModelMatrix (void)
    {
        Element::setModelMatrix();
        setSliderModelMatrix();
    }

    void setSliderModelMatrix (void)
    {
        slider_model_matrix = Eigen::Affine3f::Identity();
        // place the slider at the horizontal center of the value, and a little below the bar
        slider_model_matrix.translate (Eigen::Vector3f ((float)slider_pos[0], (float)slider_pos[1], 0.0));
        // scale slider to same scale as bar (in pixels slider should have twice the height of the bar)
        slider_model_matrix.scale (Eigen::Vector3f( (float)slider_dim[0], (float)slider_dim[1], 1.0) );
        // set y origin to top corner
        slider_model_matrix.translate (Eigen::Vector3f (0.0, 0.5, 0.0) );
    }

    void render ( Tucano::Camera &camera_2d, Shader &shader )
    {
                if (!visible)
                        return;
        
        shader.bind();

        shader.setUniform("modelMatrix", model_matrix);
        shader.setUniform("viewMatrix", camera_2d.getViewMatrix());
        shader.setUniform("projectionMatrix", camera_2d.getProjectionMatrix());
        shader.setUniform("in_Color", color);
        shader.setUniform("shapetex", texture.bind());

        quad.setAttributeLocation(shader);
        quad.bindBuffers();

        quad.renderElements();
        quad.unbindBuffers();
        texture.unbind();

        shader.setUniform("modelMatrix", slider_model_matrix);
        shader.setUniform("shapetex", slider_texture.bind());

        quad.setAttributeLocation(shader);
        quad.bindBuffers();
        quad.renderElements();

        quad.unbindBuffers();
        slider_texture.unbind();
        shader.unbind(); 
    }    

};
}
}
#endif