button_helper.hpp

Go to the documentation of this file.

/*
    Copyright 2005-2007 Adobe Systems Incorporated
    Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
    or a copy at http://stlab.adobe.com/licenses.html)
*/

/****************************************************************************************************/

#ifndef ADOBE_BUTTON_HELPER_HPP
#define ADOBE_BUTTON_HELPER_HPP

/****************************************************************************************************/

#include <adobe/config.hpp>

#include <adobe/any_regular.hpp>
#include <adobe/dictionary.hpp>
#include <adobe/widget_attributes.hpp>

#include <boost/function.hpp>
#include <boost/gil/gil_all.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>

#include <vector>
#include <string>

/****************************************************************************************************/

namespace adobe {

/****************************************************************************************************/

typedef boost::function<void (const any_regular_t&, const dictionary_t&)> button_hit_proc_t;

/****************************************************************************************************/

struct button_state_descriptor_t
{
    button_state_descriptor_t() : 
        modifier_set_m(modifiers_none_s)
    { }

    std::string name_m;

    std::string alt_text_m;

    modifiers_t modifier_set_m;

    button_hit_proc_t hit_proc_m;

    any_regular_t value_m;

    dictionary_t contributing_m;

    button_state_descriptor_t& operator=(const button_state_descriptor_t& x) 
    { /*REVISIT MOVE*/ 
        name_m = x.name_m; 
        alt_text_m = x.alt_text_m; 
        modifier_set_m = x.modifier_set_m; 
        hit_proc_m = x.hit_proc_m; 
        value_m = x.value_m; 
        contributing_m = x.contributing_m; 
        return *this;
    }

};

/****************************************************************************************************/

typedef std::vector<button_state_descriptor_t> button_state_set_t;

/****************************************************************************************************/

struct image_button_state_descriptor_t
{
    typedef boost::gil::rgba8_image_t image_type;

    image_button_state_descriptor_t() : 
        modifier_set_m(modifiers_none_s)
    { }

    image_type image_m;

    image_type disabled_image_m;

    image_type hover_image_m;

    image_type cursor_image_m;

    std::string alt_text_m;

    modifiers_t modifier_set_m;

    button_hit_proc_t hit_proc_m;

    any_regular_t value_m;

    dictionary_t contributing_m;
};

/****************************************************************************************************/

typedef std::vector<image_button_state_descriptor_t> image_button_state_set_t;

/****************************************************************************************************/

template <typename ButtonStateRange>
typename boost::range_iterator<ButtonStateRange>::type
button_modifier_state(ButtonStateRange& range,
                      modifiers_t       modifier_mask,
                      modifiers_t       modifiers)
{
    typedef typename boost::range_iterator<ButtonStateRange>::type iterator;

    modifiers &= modifier_mask;

    iterator first(boost::begin(range));
    iterator last(boost::end(range));

    for (; first != last; ++first)
        if ((first->modifier_set_m & modifiers) == modifiers)
            break;

    return first;
}

template <typename ButtonStateRange>
typename boost::range_iterator<ButtonStateRange>::type
button_default_state(ButtonStateRange& range)
{
    typename boost::range_iterator<ButtonStateRange>::type
        result(button_modifier_state(range, modifiers_none_s, modifiers_none_s));

    if (result == boost::end(range))
        throw std::runtime_error("No default state specified for button");

    return result;
}

modifiers_t name_to_modifer(name_t name);

modifiers_t value_to_modifier(const any_regular_t& modifier_set);

/*************************************************************************************************/

template <typename Control, typename UserData>
struct display_compositor_t
{
    typedef any_regular_t model_type;

    display_compositor_t(Control& control, UserData user_data) :
        control_m(control), user_data_m(user_data)
    { }

    void display(const any_regular_t& to_value)
    {
        control_m.set(user_data_m, to_value);
    }

#ifndef ADOBE_NO_DOCUMENTATION
    friend bool operator==(const display_compositor_t& lhs, const display_compositor_t& rhs)
    {
        return lhs.control_m == rhs.control_m && lhs.user_data_m == rhs.user_data_m;
    }

    Control& control_m;
    UserData user_data_m;
#endif
};

/*************************************************************************************************/

template <typename Control, typename UserData>
display_compositor_t<Control, UserData>* make_display_compositor(Control& control, UserData index)
{
    return new display_compositor_t<Control, UserData>(control, index);
}

/****************************************************************************************************/

} // namespace adobe

/****************************************************************************************************/

#endif

/****************************************************************************************************/