canola/slider.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2012 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, version 3, as
// published by the Free Software Foundation.
//
// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/ac/assert.h>

#include <lib/std_string_printf.h>

#include <canola/load_image.h>
#include <canola/slider.h>


slider::~slider()
{
}


static img_ptr_t
load_image(const std::string &name, int n)
{
    std::string filename = std_string_printf("%s-switch-%d", name.c_str(), n);
    return load_gui_image(filename);
}


slider::slider(const std::string &name, int a_nvalues, bool act_on_rel) :
    nvalues(a_nvalues),
    value(0),
    down(false),
    inside(false),
    old_value(0),
    frac(1),
    activate_on_release(act_on_rel)
{
    assert(nvalues >= 2);
    for (int n = 0; n < nvalues; ++n)
        value_images.push_back(load_image(name, n));

    appearance.set(value_images[value]);
    add(appearance);

    set_size_request
    (
        value_images[0]->get_width(),
        value_images[0]->get_height()
    );

    signal_button_press_event().connect(sigc::mem_fun(this,
        &slider::on_button_press));
    signal_button_release_event().connect(sigc::mem_fun(this,
        &slider::on_button_release));
    signal_motion_notify_event().connect(sigc::mem_fun(this,
        &slider::on_motion_notify));

    show_all_children();
    frac = value_images[value]->get_width() / nvalues;
    assert(frac >= 1);

    override_background_color(custom_widget_background, Gtk::STATE_FLAG_NORMAL);
}


bool
slider::on_button_press(GdkEventButton *ep)
{
    down = true;
    inside = true;
    old_value = value;
    update_value(ep->x, ep->y);
    return true;
}


bool
slider::on_button_release(GdkEventButton *)
{
    if (activate_on_release)
    {
        if (inside)
            value_changed_source.emit();
    }
    down = false;
    inside = false;
    old_value = value;
    return true;
}


bool
slider::on_motion_notify(GdkEventMotion *ep)
{
    if (!down)
        return false;
    update_value(ep->x, ep->y);
    return true;
}


void
slider::update_value(int x, int y)
{
    pixbuf_pointer p = value_images[value];
    x -= (get_allocated_width() - p->get_width()) / 2;
    y -= (get_allocated_height() - p->get_height()) / 2;

    if (x > 0 && x < p->get_width() && y > 0 && y < p->get_height())
    {
        inside = true;
        int n = x / frac;
        if (n < 0)
            n = 0;
        else if (n >= nvalues)
            n = nvalues - 1;
        if (n != value)
        {
            value = n;
            appearance.set(value_images[value]);
            if (!activate_on_release)
                value_changed_source.emit();
        }
    }
    else
    {
        if (inside)
        {
            value = old_value;
            appearance.set(value_images[value]);
            if (!activate_on_release)
                value_changed_source.emit();
        }
        inside = false;
    }
}


int
slider::get_value(void)
    const
{
    return value;
}


slider::value_changed_signal_t &
slider::value_changed_signal(void)
{
    return value_changed_source;
}


void
slider::set_value(int n)
{
    if (n < 0)
        value = 0;
    else if (n >= nvalues)
        value = nvalues - 1;
    else
        value = n;
    appearance.set(value_images[value]);
}