poly_placeable.hpp

Go to the documentation of this file.

/*
    Copyright 2006-2007 Adobe Systems Incorporated
    Distributed under the Boost Software License - Version 1.0 (see the accompanying file LICENSE
    or a copy at https://stlab.github.io/adobe_source_libraries/licenses.html)
 
    Author(s): Mat Marcus
*/
 
/**************************************************************************************************/
#ifndef ADOBE_POLY_PLACEABLE_HPP
#define ADOBE_POLY_PLACEABLE_HPP
 
#include <boost/ref.hpp>
 
#include <adobe/config.hpp>
#include <adobe/layout_attributes.hpp>
#include <adobe/placeable_concept.hpp>
#include <adobe/poly.hpp>
 
 
/**************************************************************************************************/
 
namespace adobe {
 
/**************************************************************************************************/
 
struct poly_placeable_interface : poly_copyable_interface {
    virtual void measure(extents_t& result) = 0;
    virtual void place(const place_data_t& place_data) = 0;
};
 
/**************************************************************************************************/

 
template <typename T>
struct poly_placeable_instance : optimized_storage_type<T, poly_placeable_interface>::type {
    typedef typename optimized_storage_type<T, poly_placeable_interface>::type base_t;
 
    BOOST_CLASS_REQUIRE(T, adobe, PlaceableConcept);
 
    poly_placeable_instance(const T& x) : base_t(x) {}
    poly_placeable_instance(poly_placeable_instance&& x) : base_t(std::move(x)) {}
 
    void measure(extents_t& result) { PlaceableConcept<T>::measure(this->get(), result); }
 
    void place(const place_data_t& place_data) {
        PlaceableConcept<T>::place(this->get(), place_data);
    }
};
 
 
/**************************************************************************************************/

 
struct placeable : public poly_base<poly_placeable_interface, poly_placeable_instance> {
    typedef poly_base<poly_placeable_interface, poly_placeable_instance> base_t;
 
    template <typename T>
    explicit placeable(const T& x) : base_t(x) {}
 
    placeable(placeable&& x) : base_t(std::move(x)) {}
 
    void measure(extents_t& result) { interface_ref().measure(result); }
 
    void place(const place_data_t& place_data) { interface_ref().place(place_data); }
};
 
/**************************************************************************************************/

typedef poly<placeable> poly_placeable_t;
 
/**************************************************************************************************/

struct poly_placeable_twopass_interface : public poly_placeable_interface {
    virtual void measure_vertical(extents_t& in_out_attrs,
                                  const place_data_t& placed_horizontal) = 0;
};
 
/**************************************************************************************************/

template <typename T>
struct poly_placeable_twopass_instance
    : optimized_storage_type<T, poly_placeable_twopass_interface>::type {
    typedef typename optimized_storage_type<T, poly_placeable_twopass_interface>::type base_t;
 
    BOOST_CLASS_REQUIRE(T, adobe, PlaceableTwoPassConcept);
 
    poly_placeable_twopass_instance(const T& x) : base_t(x) {}
    poly_placeable_twopass_instance(poly_placeable_twopass_instance&& x) : base_t(std::move(x)) {}
 
    void measure(extents_t& result) { PlaceableTwoPassConcept<T>::measure(this->get(), result); }
 
    void measure_vertical(extents_t& calculated_horizontal, const place_data_t& placed_horizontal) {
        PlaceableTwoPassConcept<T>::measure_vertical(this->get(), calculated_horizontal,
                                                     placed_horizontal);
    }
 
    void place(const place_data_t& place_data) {
        PlaceableTwoPassConcept<T>::place(this->get(), place_data);
    }
};
 
/**************************************************************************************************/

struct placeable_twopass
    : public poly_base<poly_placeable_twopass_interface, poly_placeable_twopass_instance> {
    typedef poly_base<poly_placeable_twopass_interface, poly_placeable_twopass_instance> base_t;
 
    template <typename T>
    explicit placeable_twopass(const T& x) : base_t(x) {}
 
    placeable_twopass(placeable_twopass&& x) : base_t(std::move(x)) {}
 
    void measure(extents_t& result) { interface_ref().measure(result); }
 
    void measure_vertical(extents_t& calculated_horizontal, const place_data_t& placed_horizontal) {
        interface_ref().measure_vertical(calculated_horizontal, placed_horizontal);
    }
 
    void place(const place_data_t& place_data) { interface_ref().place(place_data); }
};
 
/**************************************************************************************************/

 
typedef poly<placeable_twopass> poly_placeable_twopass_t;
 
/**************************************************************************************************/
 
} // namespace adobe
 
/**************************************************************************************************/
 
#endif