DisplayList.h

Go to the documentation of this file.

// dlist.h:  Display list definitions, for Gnash.
// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// 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, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef GNASH_DLIST_H
#define GNASH_DLIST_H

#include "snappingrange.h"

#include <string>
#include <list>
#include <iosfwd>
#if GNASH_PARANOIA_LEVEL > 1 && !defined(NDEBUG)
#include "DisplayObject.h"
#include <set>  // for testInvariant
#include <algorithm>
#include "log.h"
#endif

// GNASH_PARANOIA_LEVEL:
// 0 : (not unimplemented)
// 1 : quick assertions
// 2 : add testInvariant
//
#ifndef GNASH_PARANOIA_LEVEL
# define GNASH_PARANOIA_LEVEL 1
#endif

namespace gnash {
    class SWFCxForm;
    class Renderer;
    struct ObjectURI;
    class Transform;
    class string_table;
    class DisplayObject;
    class SWFMatrix;
}

namespace gnash {

//
class DisplayList
{

public:

        typedef std::list<DisplayObject*> container_type;
        typedef container_type::iterator iterator;
        typedef container_type::const_iterator const_iterator;
        typedef container_type::reverse_iterator reverse_iterator;
        typedef container_type::const_reverse_iterator const_reverse_iterator;

    DisplayList() {}
    ~DisplayList() {}

        friend std::ostream& operator<< (std::ostream&, const DisplayList&);

        //
    void placeDisplayObject(DisplayObject* ch, int depth);

        //
        void replaceDisplayObject(DisplayObject* ch, int depth, bool use_old_cxform,
                bool use_old_matrix);

        //
        void swapDepths(DisplayObject* ch, int depth);

        //
        //
        void moveDisplayObject(int depth, const SWFCxForm* color_xform,
            const SWFMatrix* mat, boost::uint16_t* ratio);

        //
        void removeDisplayObject(int depth);

        //
        void removeUnloaded();

        bool unload();

        void destroy();

        //
        void add(DisplayObject* ch, bool replace);

    //
    //
    void insertDisplayObject(DisplayObject* obj, int index);

    //
        void display(Renderer& renderer, const Transform& xform);
        
        void omit_display();

        DisplayObject* getDisplayObjectAtDepth(int depth) const;

        //
        DisplayObject* getDisplayObjectByName(string_table& st,
            const ObjectURI& uri, bool caseless) const;

        //
        template <class V> inline void visitBackward(V& visitor);
    template <class V> inline void visitBackward(V& visitor) const;

        //
        template <class V> inline void visitAll(V& visitor);
        template <class V> inline void visitAll(V& visitor) const;

        void add_invalidated_bounds(InvalidatedRanges& ranges, bool force);     
        
        size_t size() const { 
                return _charsByDepth.size();
        }

        bool empty() const {
                return _charsByDepth.empty();
        }

        //
        int getNextHighestDepth() const;
        
    //
        void mergeDisplayList(DisplayList& newList, DisplayObject& o);

        bool operator==(const DisplayList& other) const {
        return _charsByDepth == other._charsByDepth;
    }

        bool operator!=(const DisplayList& other) const {
        return _charsByDepth != other._charsByDepth;
    }
        
#if GNASH_PARANOIA_LEVEL > 1 && !defined(NDEBUG)
    DisplayList::const_iterator nonRemoved() const;

    void testInvariant() const
        {
                DisplayList sorted = *this;

        // check no duplicated depths above non-removed zone.
                std::set<int> depths;
                for (const_iterator it = nonRemoved(),
                itEnd = _charsByDepth.end(); it != itEnd; ++it) {

                        DisplayObject* ch = *it;
                        int depth = ch->get_depth();
                        if (!depths.insert(depth).second) {
                                log_debug("Depth %d is duplicated in DisplayList %p",
                        depth, (const void*)this);
                std::abort();
                        }
                }
        if (_charsByDepth.empty()) return;
                // check we didn't screw up ordering
        assert(std::adjacent_find(_charsByDepth.begin(), _charsByDepth.end(),
            DepthGreaterThan()) == _charsByDepth.end());
        }
#else
    void testInvariant() const {}
#endif 

private:

        //
        void reinsertRemovedCharacter(DisplayObject* ch);

        container_type _charsByDepth;
};

template <class V>
void
DisplayList::visitBackward(V& visitor)
{
        for (reverse_iterator it = _charsByDepth.rbegin(),
                        itEnd = _charsByDepth.rend(); it != itEnd; ++it) {
                if (!visitor(*it)) break;
        }
}

template <class V>
void
DisplayList::visitBackward(V& visitor) const
{
        for (const_reverse_iterator it = _charsByDepth.rbegin(),
                        itEnd = _charsByDepth.rend(); it != itEnd; ++it) {
                if (!visitor(*it)) break;
        }
}

template <class V>
void
DisplayList::visitAll(V& visitor)
{
        for (iterator it = _charsByDepth.begin(), itEnd = _charsByDepth.end();
                it != itEnd; ++it) {

                visitor(*it);
        }
}

template <class V>
void
DisplayList::visitAll(V& visitor) const
{
        for (const_iterator it = _charsByDepth.begin(),
            itEnd = _charsByDepth.end(); it != itEnd; ++it) {

                visitor(*it);
        }
}

std::ostream& operator<< (std::ostream&, const DisplayList&);

} // namespace gnash


#endif // GNASH_DLIST_H



// Local Variables:
// mode: C++
// c-basic-offset: 8 
// tab-width: 8
// indent-tabs-mode: t
// End: