path: root/src/display/drawing-item.cpp

/**
 * @file
 * @brief Canvas item belonging to an SVG drawing element
 *//*
 * Authors:
 *   Krzysztof Kosiński <tweenk.pl@gmail.com>
 *
 * Copyright (C) 2011 Authors
 * Released under GNU GPL, read the file 'COPYING' for more information
 */

#include "display/cairo-utils.h"
#include "display/cairo-templates.h"
#include "display/drawing.h"
#include "display/drawing-context.h"
#include "display/drawing-item.h"
#include "display/drawing-group.h"
#include "display/drawing-surface.h"
#include "nr-filter.h"
#include "preferences.h"
#include "style.h"

namespace Inkscape {

/** @class DrawingItem
 * @brief SVG drawing item for display.
 *
 * This was previously known as NRArenaItem. It represents the renderable
 * portion of the SVG document. Typically this is created by the SP tree,
 * in particular the show() virtual function.
 *
 * @section ObjectLifetime Object Lifetime
 * Deleting a DrawingItem will cause all of its children to be deleted as well.
 * This can lead to nasty surprises if you hold references to things
 * which are children of what is being deleted. Therefore, in the SP tree,
 * you always need to delete the item views of children before deleting
 * the view of the parent. Do not call delete on things returned from show()
 * - this will cause dangling pointers inside the SPItem and lead to a crash.
 * Use the corresponing hide() method.
 *
 * Outside of the SP tree you should not use any references after the root node
 * has been deleted.
 */

DrawingItem::DrawingItem(Drawing &drawing)
    : _drawing(drawing)
    , _parent(NULL)
    , _key(0)
    , _opacity(1.0)
    , _transform(NULL)
    , _clip(NULL)
    , _mask(NULL)
    , _filter(NULL)
    , _user_data(NULL)
    , _cache(NULL)
    , _state(0)
    , _visible(true)
    , _sensitive(true)
    , _cached(0)
    , _propagate(0)
//    , _renders_opacity(0)
    , _clip_child(0)
    , _mask_child(0)
    , _drawing_root(0)
    , _pick_children(0)
{
}

DrawingItem::~DrawingItem()
{
    _drawing.signal_item_deleted.emit(this);
    //if (!_children.empty()) {
    //    g_warning("Removing item with children");
    //}

    // remove from the set of cached items
    if (_cached) {
        _drawing._cached_items.erase(this);
    }
    // remove this item from parent's children list
    // due to the effect of clearChildren(), this only happens for the top-level deleted item
    if (_parent) {
        _markForRendering();
        // we cannot call setClip(NULL) or setMask(NULL),
        // because that would be an endless loop
        if (_clip_child) {
            _parent->_clip = NULL;
        } else if (_mask_child) {
            _parent->_mask = NULL;
        } else {
            ChildrenList::iterator ithis = _parent->_children.iterator_to(*this);
            _parent->_children.erase(ithis);
        }
        _parent->_markForUpdate(STATE_ALL, false);
    } else if (_drawing_root) {
        _drawing._root = NULL;
    }
    clearChildren();
    delete _transform;
    delete _clip;
    delete _mask;
    delete _filter;
}

DrawingItem *
DrawingItem::parent() const
{
    // initially I wanted to return NULL if we are a clip or mask child,
    // but the previous behavior was just to return the parent
    return _parent;
}

void
DrawingItem::appendChild(DrawingItem *item)
{
    item->_parent = this;
    _children.push_back(*item);
    _markForUpdate(STATE_ALL, false);
}

void
DrawingItem::prependChild(DrawingItem *item)
{
    item->_parent = this;
    _children.push_front(*item);
    _markForUpdate(STATE_ALL, false);
}

/// Delete all regular children of this item (not mask or clip).
void
DrawingItem::clearChildren()
{
    // prevent children from referencing the parent during deletion
    // this way, children won't try to remove themselves from a list
    // from which they have already been removed by clear_and_dispose
    for (ChildrenList::iterator i = _children.begin(); i != _children.end(); ++i) {
        i->_parent = NULL;
    }
    _children.clear_and_dispose(DeleteDisposer());
}

/// Set the incremental transform for this item
void
DrawingItem::setTransform(Geom::Affine const &new_trans)
{
    Geom::Affine current;
    if (_transform) {
        current = *_transform;
    }
    
    if (!Geom::are_near(current, new_trans, NR_EPSILON)) {
        // mark the area where the object was for redraw.
        _markForRendering();
        if (new_trans.isIdentity()) {
            delete _transform; // delete NULL; is safe
            _transform = NULL;
        } else {
            _transform = new Geom::Affine(new_trans);
        }
        _markForUpdate(STATE_ALL, true);
    }
}

void
DrawingItem::setOpacity(float opacity)
{
    _opacity = opacity;
    _markForRendering();
}

void
DrawingItem::setVisible(bool v)
{
    _visible = v;
    _markForRendering();
}

/// This is currently unused
void
DrawingItem::setSensitive(bool s)
{
    _sensitive = s;
}

/// Enable / disable storing the rendering in memory.
void
DrawingItem::setCached(bool c)
{
    _cached = c;
    if (c) {
        _drawing._cached_items.insert(this);
    } else {
        _drawing._cached_items.erase(this);
    }
    _markForUpdate(STATE_CACHE, false);
}

void
DrawingItem::setClip(DrawingItem *item)
{
    _markForRendering();
    delete _clip;
    _clip = item;
    if (item) {
        item->_parent = this;
        item->_clip_child = true;
    }
    _markForUpdate(STATE_ALL, true);
}

void
DrawingItem::setMask(DrawingItem *item)
{
    _markForRendering();
    delete _mask;
    _mask = item;
        if (item) {
        item->_parent = this;
        item->_mask_child = true;
    }
    _markForUpdate(STATE_ALL, true);
}

/// Move this item to the given place in the Z order of siblings.
/// Does nothing if the item has no parent.
void
DrawingItem::setZOrder(unsigned z)
{
    if (!_parent) return;

    ChildrenList::iterator it = _parent->_children.iterator_to(*this);
    _parent->_children.erase(it);

    ChildrenList::iterator i = _parent->_children.begin();
    std::advance(i, std::min(z, unsigned(_parent->_children.size())));
    _parent->_children.insert(i, *this);
    _markForRendering();
}

void
DrawingItem::setItemBounds(Geom::OptRect const &bounds)
{
    _item_bbox = bounds;
}

/** @brief Update derived data before operations.
 * The purpose of this call is to recompute internal data which depends
 * on the attributes of the object, but is not directly settable by the user.
 * Precomputing this data speeds up later rendering, because some items
 * can be omitted.
 *
 * Currently this method handles updating the visual and geometric bounding boxes
 * in pixels, storing the total transformation from item space to the screen
 * and cache invalidation.
 *
 * @param area Area to which the update should be restricted. Only takes effect
 *             if the bounding box is known.
 * @param ctx A structure to store cascading state.
 * @param flags Which internal data should be recomputed. This can be any combination
 *              of StateFlags.
 * @param reset State fields that should be reset before processing them. This is
 *              a means to force a recomputation of internal data even if the item
 *              considers it up to date. Mainly for internal use, such as
 *              propagating bunding box recomputation to children when the item's
 *              transform changes.
 */
void
DrawingItem::update(Geom::IntRect const &area, UpdateContext const &ctx, unsigned flags, unsigned reset)
{
    bool render_filters = _drawing.renderFilters();
    bool outline = _drawing.outline();

    // Set reset flags according to propagation status
    if (_propagate) {
        reset |= ~_state;
        _propagate = FALSE;
    }
    _state &= ~reset; // reset state of this item

    if ((~_state & flags) == 0) return; // nothing to do

    // TODO this might be wrong
    if (_state & STATE_BBOX) {
        // we have up-to-date bbox
        if (!area.intersects(outline ? _bbox : _drawbox)) return;
    }

    UpdateContext child_ctx(ctx);
    if (_transform) {
        child_ctx.ctm = *_transform * ctx.ctm;
    }
    /* Remember the transformation matrix */
    Geom::Affine ctm_change = _ctm.inverse() * child_ctx.ctm;
    _ctm = child_ctx.ctm;

    // update _bbox
    _state = _updateItem(area, child_ctx, flags, reset);

    // compute drawbox
    if (_filter && render_filters && _item_bbox) {
        _drawbox = _filter->compute_drawbox(this, *_item_bbox);
    } else {
        _drawbox = _bbox;
    }

    // Clipping
    if (_clip) {
        _clip->update(area, child_ctx, flags, reset);
        if (outline) {
            _bbox.unionWith(_clip->_bbox);
        } else {
            _drawbox.intersectWith(_clip->_bbox);
        }
    }
    // masking
    if (_mask) {
        _mask->update(area, child_ctx, flags, reset);
        if (outline) {
            _bbox.unionWith(_mask->_bbox);
        } else {
            // for masking, we need full drawbox of mask
            _drawbox.intersectWith(_mask->_drawbox);
        }
    }

    // update cache if enabled
    if (_cached) {
        Geom::OptIntRect cl = _drawing.cacheLimit();
        cl.intersectWith(_drawbox);
        if (cl) {
            if (_cache) {
                // this takes care of invalidation on transform
                _cache->resizeAndTransform(*cl, ctm_change);
            } else {
                _cache = new Inkscape::DrawingCache(*cl);
                // the cache is initially dirty
            }
        } else {
            // disable cache for this item - not visible
            delete _cache;
            _cache = NULL;
        }
    }

    // now that we know drawbox, dirty the corresponding rect on canvas
    // unless filtered, groups do not need to render by themselves, only their members
    if (!is_drawing_group(this) || (_filter && render_filters)) {
        if (flags & ~STATE_CACHE) {
            _markForRendering();
        }
    }
}

struct MaskLuminanceToAlpha {
    guint32 operator()(guint32 in) {
        EXTRACT_ARGB32(in, a, r, g, b)
        // the operation of unpremul -> luminance-to-alpha -> multiply by alpha
        // is equivalent to luminance-to-alpha on premultiplied color values
        // original computation in double: r*0.2125 + g*0.7154 + b*0.0721
        guint32 ao = r*109 + g*366 + b*37; // coeffs add up to 512
        return ((ao + 256) << 15) & 0xff000000; // equivalent to ((ao + 256) / 512) << 24
    }
};

/** @brief Rasterize items.
 * This method submits the drawing opeartions required to draw this item
 * to the supplied DrawingContext, restricting drawing the the specified area.
 *
 * This method does some common tasks and calls the item-specific rendering
 * function, _renderItem(), to render e.g. paths or bitmaps.
 *
 * @param flags Rendering options. This deals mainly with cache control.
 */
void
DrawingItem::render(DrawingContext &ct, Geom::IntRect const &area, unsigned flags)
{
    bool outline = _drawing.outline();
    bool render_filters = _drawing.renderFilters();

    /* If we are invisible, just return successfully */
    if (!_visible) return;

    if (outline) {
        _renderOutline(ct, area, flags);
        return;
    }

    // carea is the bounding box for intermediate rendering.
    Geom::OptIntRect carea = Geom::intersect(area, _drawbox);
    if (!carea) return;

    // render from cache
    if (_cached && _cache) {
        if (_cache->paintFromCache(ct, *carea))
            return;
    }

    // expand carea to contain the dependent area of filters.
    if (_filter && render_filters) {
        _filter->area_enlarge(*carea, this);
        carea.intersectWith(_drawbox);
    }

    // determine whether this shape needs intermediate rendering.
    bool needs_intermediate_rendering = false;
    bool &nir = needs_intermediate_rendering;
    bool needs_opacity = (_opacity < 0.995);

    // this item needs an intermediate rendering if:
    nir |= (_clip != NULL); // 1. it has a clipping path
    nir |= (_mask != NULL); // 2. it has a mask
    nir |= (_filter != NULL && render_filters); // 3. it has a filter
    nir |= needs_opacity; // 4. it is non-opaque

    /* How the rendering is done.
     *
     * Clipping, masking and opacity are done by rendering them to a surface
     * and then compositing the object's rendering onto it with the IN operator.
     * The object itself is rendered to a group.
     *
     * Opacity is done by rendering the clipping path with an alpha
     * value corresponding to the opacity. If there is no clipping path,
     * the entire intermediate surface is painted with alpha corresponding
     * to the opacity value.
     */

    // short-circuit the simple case.
    if (!needs_intermediate_rendering) {
        if (_cached && _cache) {
            Inkscape::DrawingContext cachect(*_cache);
            cachect.rectangle(area);
            cachect.clip();

            {   // 1. clear the corresponding part of cache
                Inkscape::DrawingContext::Save save(cachect);
                cachect.setSource(0,0,0,0);
                cachect.setOperator(CAIRO_OPERATOR_SOURCE);
                cachect.paint();
            }
            // 2. render to cache
            _renderItem(cachect, *carea, flags);
            // 3. copy from cache to output
            Inkscape::DrawingContext::Save save(ct);
            ct.rectangle(*carea);
            ct.clip();
            ct.setSource(_cache);
            ct.paint();
            // 4. mark as clean
            _cache->markClean(area);
            return;
        } else {
            _renderItem(ct, *carea, flags);
            return;
        }
    }

    DrawingSurface intermediate(*carea);
    DrawingContext ict(intermediate);

    // 1. Render clipping path with alpha = opacity.
    ict.setSource(0,0,0,_opacity);
    // Since clip can be combined with opacity, the result could be incorrect
    // for overlapping clip children. To fix this we use the SOURCE operator
    // instead of the default OVER.
    ict.setOperator(CAIRO_OPERATOR_SOURCE);
    if (_clip) {
        _clip->clip(ict, *carea); // fixme: carea or area?
    } else {
        // if there is no clipping path, fill the entire surface with alpha = opacity.
        ict.paint();
    }
    ict.setOperator(CAIRO_OPERATOR_OVER); // reset back to default

    // 2. Render the mask if present and compose it with the clipping path + opacity.
    if (_mask) {
        ict.pushGroup();
        _mask->render(ict, *carea, flags);

        cairo_surface_t *mask_s = ict.rawTarget();
        // Convert mask's luminance to alpha
        ink_cairo_surface_filter(mask_s, mask_s, MaskLuminanceToAlpha());
        ict.popGroupToSource();
        ict.setOperator(CAIRO_OPERATOR_IN);
        ict.paint();
        ict.setOperator(CAIRO_OPERATOR_OVER);
    }

    // 3. Render object itself.
    ict.pushGroup();
    _renderItem(ict, *carea, flags);

    // 4. Apply filter.
    if (_filter && render_filters) {
        _filter->render(this, ct, ict);
        // Note that because the object was rendered to a group,
        // the internals of the filter need to use cairo_get_group_target()
        // instead of cairo_get_target().
    }

    // 5. Render object inside the composited mask + clip
    ict.popGroupToSource();
    ict.setOperator(CAIRO_OPERATOR_IN);
    ict.paint();

    // 6. Paint the completed rendering onto the base context (or into cache)
    if (_cached && _cache) {
        DrawingContext cachect(*_cache);
        cachect.rectangle(area);
        cachect.clip();
        cachect.setOperator(CAIRO_OPERATOR_SOURCE);
        cachect.setSource(&intermediate);
        cachect.paint();
        _cache->markClean(area);
    }
    ct.setSource(&intermediate);
    ct.paint();
    ct.setSource(0,0,0,0);
    // the call above is to clear a ref on the intermediate surface held by ct
}

void
DrawingItem::_renderOutline(DrawingContext &ct, Geom::IntRect const &area, unsigned flags)
{
    // intersect with bbox rather than drawbox, as we want to render things outside
    // of the clipping path as well
    Geom::OptIntRect carea = Geom::intersect(area, _bbox);
    if (!carea) return;

    // just render everything: item, clip, mask
    // First, render the object itself
    _renderItem(ct, *carea, flags);

    // render clip and mask, if any
    guint32 saved_rgba = _drawing.outlinecolor; // save current outline color
    // render clippath as an object, using a different color
    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
    if (_clip) {
        _drawing.outlinecolor = prefs->getInt("/options/wireframecolors/clips", 0x00ff00ff); // green clips
        _clip->render(ct, *carea, flags);
    }
    // render mask as an object, using a different color
    if (_mask) {
        _drawing.outlinecolor = prefs->getInt("/options/wireframecolors/masks", 0x0000ffff); // blue masks
        _mask->render(ct, *carea, flags);
    }
    _drawing.outlinecolor = saved_rgba; // restore outline color
}

/** @brief Rasterize the clipping path.
 * This method submits drawing operations required to draw a basic filled shape
 * of the item to the supplied drawing context. Rendering is limited to the
 * given area. The rendering of the clipped object is composited into
 * the result of this call using the IN operator. See the implementation
 * of render() for details.
 */
void
DrawingItem::clip(Inkscape::DrawingContext &ct, Geom::IntRect const &area)
{
    // don't bother if the object does not implement clipping (e.g. DrawingImage)
    if (!_canClip()) return;
    if (!_visible) return;
    if (!area.intersects(_bbox)) return;

    // The item used as the clipping path itself has a clipping path.
    // Render this item's clipping path onto a temporary surface, then composite it
    // with the item using the IN operator
    if (_clip) {
        ct.pushAlphaGroup();
        {   Inkscape::DrawingContext::Save save(ct);
            ct.setSource(0,0,0,1);
            _clip->clip(ct, area);
        }
        ct.pushAlphaGroup();
    }

    // rasterize the clipping path
    _clipItem(ct, area);
    
    if (_clip) {
        ct.popGroupToSource();
        ct.setOperator(CAIRO_OPERATOR_IN);
        ct.paint();
        ct.popGroupToSource();
        ct.setOperator(CAIRO_OPERATOR_SOURCE);
        ct.paint();
    }
}

/** @brief Get the item under the specified point.
 * Searches the tree for the first item in the Z-order which is closer than
 * @a delta to the given point. The pick should be visual - for example
 * an object with a thick stroke should pick on the entire area of the stroke.
 * @param p Search point
 * @param delta Maximum allowed distance from the point
 * @param sticky Whether the pick should ignore visibility and sensitivity.
 *               When false, only visible and sensitive objects are considered.
 *               When true, invisible and insensitive objects can also be picked.
 */
DrawingItem *
DrawingItem::pick(Geom::Point const &p, double delta, bool sticky)
{
    // Sometimes there's no BBOX in state, reason unknown (bug 992817)
    // I made this not an assert to remove the warning
    if (!(_state & STATE_BBOX) || !(_state & STATE_PICK))
        return NULL;

    if (!sticky && !(_visible && _sensitive))
        return NULL;

    if (!_bbox) return NULL;
    Geom::Rect expanded(*_bbox);
    expanded.expandBy(delta);

    if (expanded.contains(p)) {
        return _pickItem(p, delta, sticky);
    }
    return NULL;
}

/** Marks the current visual bounding box of the item for redrawing.
 * This is called whenever the object changes its visible appearance.
 * For some cases (such as setting opacity) this is enough, but for others
 * _markForUpdate() also needs to be called.
 */
void
DrawingItem::_markForRendering()
{
    bool outline = _drawing.outline();
    Geom::OptIntRect dirty = outline ? _bbox : _drawbox;
    if (!dirty) return;

    // dirty the caches of all parents
    for (DrawingItem *i = this; i; i = i->_parent) {
        if (i->_cached && i->_cache) {
            i->_cache->markDirty(*dirty);
        }
    }
    _drawing.signal_request_render.emit(*dirty);
}

/** @brief Marks the item as needing a recomputation of internal data.
 *
 * This mechanism avoids traversing the entire rendering tree (which could be vast)
 * on every trivial state changed in any item. Only items marked as needing
 * an update (having some bits in their _state unset) will be traversed
 * during the update call.
 *
 * The _propagate variable is another optimization. We use it to specify that
 * all children should also have the corresponding flags unset before checking
 * whether they need to be traversed. This way there is one less traversal
 * of the tree. Without this we would need to unset state bits in all children.
 * With _propagate we do this during the update call, when we have to traverse
 * the tree anyway.
 */
void
DrawingItem::_markForUpdate(unsigned flags, bool propagate)
{
    // we can't simply assign because a previous markForUpdate call
    // could have had propagate=true even if this one has propagate=false
    if (propagate)
        _propagate = true;

    if (_state & flags) {
        _state &= ~flags;
        if (_parent) {
            _parent->_markForUpdate(flags, false);
        } else {
            _drawing.signal_request_update.emit(this);
        }
    }
}

void
DrawingItem::_setStyleCommon(SPStyle *&_style, SPStyle *style)
{
    if (style) sp_style_ref(style);
    if (_style) sp_style_unref(_style);
    _style = style;

    // if group has a filter
    if (style->filter.set && style->getFilter()) {
        if (!_filter) {
            int primitives = sp_filter_primitive_count(SP_FILTER(style->getFilter()));
            _filter = new Inkscape::Filters::Filter(primitives);
        }
        sp_filter_build_renderer(SP_FILTER(style->getFilter()), _filter);
    } else {
        // no filter set for this group
        delete _filter;
        _filter = NULL;
    }

    /*
    if (style && style->enable_background.set
        && style->enable_background.value == SP_CSS_BACKGROUND_NEW) {
        _background_new = true;
    }*/
}

} // end namespace Inkscape

/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :