fabric/window.h

/* Copyright (c) 2010-2013, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2014, Daniel Nachbaur <danielnachbaur@gmail.com>
 *                    2010, Cedric Stalder <cedric.stalder@gmail.com>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library 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 Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQFABRIC_WINDOW_H
#define EQFABRIC_WINDOW_H

#include <eq/fabric/object.h> // base class

#include <eq/fabric/drawableConfig.h> // enum
#include <eq/fabric/paths.h>
#include <eq/fabric/pixelViewport.h>
#include <eq/fabric/viewport.h>
#include <eq/fabric/windowSettings.h>

namespace eq
{
namespace fabric
{
template <class P, class W, class C, class Settings = WindowSettings>
class Window : public Object
{
public:
    typedef std::vector<C*> Channels;
    typedef ElementVisitor<W, LeafVisitor<C>> Visitor;

    void init();

    const P* getPipe() const { return _pipe; }
    P* getPipe() { return _pipe; }
    const Channels& getChannels() const { return _channels; }
    const DrawableConfig& getDrawableConfig() const
    {
        return _data.drawableConfig;
    }

    EQFABRIC_INL const PixelViewport& getPixelViewport() const;

    const Viewport& getViewport() const { return _data.vp; }
    EQFABRIC_INL void setName(const std::string& name) final;

    EQFABRIC_INL virtual void setPixelViewport(const PixelViewport& pvp);

    EQFABRIC_INL void setViewport(const Viewport& vp);

    bool hasFixedViewport() const { return _data.fixedVP; }
    virtual void notifyViewportChanged();

    EQFABRIC_INL VisitorResult accept(Visitor& visitor);

    EQFABRIC_INL VisitorResult accept(Visitor& visitor) const;


    EQFABRIC_INL void setSettings(const Settings& settings);

    EQFABRIC_INL const Settings& getSettings() const;

    EQFABRIC_INL void setIAttribute(const WindowSettings::IAttribute attr,
                                    const int32_t value);

    EQFABRIC_INL int32_t
        getIAttribute(const WindowSettings::IAttribute attr) const;

    EQFABRIC_INL static const std::string& getIAttributeString(
        const WindowSettings::IAttribute attr);

    EQFABRIC_INL WindowPath getPath() const;

    EQFABRIC_INL virtual void backup();         
    EQFABRIC_INL virtual void restore();        
    void create(C** channel);                   
    void release(C* channel);                   
    virtual void output(std::ostream&) const {} 

    EQFABRIC_INL virtual uint128_t commit(
        const uint32_t incarnation = CO_COMMIT_NEXT);

protected:
    explicit Window(P* parent);

    EQFABRIC_INL virtual ~Window(); 

    virtual void attach(const uint128_t& id, const uint32_t instanceID);

    EQFABRIC_INL virtual void serialize(co::DataOStream& os,
                                        const uint64_t dirtyBits);
    EQFABRIC_INL virtual void deserialize(co::DataIStream& is,
                                          const uint64_t dirtyBits);

    EQFABRIC_INL virtual void notifyDetach(); 

    EQFABRIC_INL virtual void setDirty(const uint64_t bits);

    void _setDrawableConfig(const DrawableConfig& drawableConfig);

    virtual ChangeType getChangeType() const { return UNBUFFERED; }
    C* _findChannel(const uint128_t& id); 

    enum DirtyBits
    {
        DIRTY_SETTINGS = Object::DIRTY_CUSTOM << 0,
        DIRTY_CHANNELS = Object::DIRTY_CUSTOM << 1,
        DIRTY_VIEWPORT = Object::DIRTY_CUSTOM << 2,
        DIRTY_DRAWABLECONFIG = Object::DIRTY_CUSTOM << 3,
        DIRTY_WINDOW_BITS = DIRTY_SETTINGS | DIRTY_CHANNELS | DIRTY_VIEWPORT |
                            DIRTY_DRAWABLECONFIG | DIRTY_OBJECT_BITS
    };

    virtual uint64_t getRedistributableBits() const
    {
        return DIRTY_WINDOW_BITS;
    }

private:
    P* const _pipe;

    Channels _channels;

    struct BackupData
    {
        BackupData();

        Settings windowSettings;

        DrawableConfig drawableConfig;

        PixelViewport pvp;

        Viewport vp;

        bool fixedVP;
    } _data, _backup;

    struct Private;
    Private* _private; // placeholder for binary-compatible changes

    friend class Channel<W, C>;
    void _addChannel(C* channel);

    EQFABRIC_INL bool _removeChannel(C* channel);

    bool _mapNodeObjects() { return _pipe->_mapNodeObjects(); }
    typedef co::CommandFunc<Window<P, W, C, Settings>> CmdFunc;
    bool _cmdNewChannel(co::ICommand& command);
    bool _cmdNewChannelReply(co::ICommand& command);
};

template <class P, class W, class C, class Settings>
EQFABRIC_INL std::ostream& operator<<(std::ostream& os,
                                      const Window<P, W, C, Settings>& window);
}
}

#endif // EQFABRIC_WINDOW_H