• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMContext.h

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// 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 2
// of the License, or (at your option) any later version.
// 
// This program 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 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


#ifndef __PCM_CONTEXT_H__
#  define __PCM_CONTEXT_H__

//
// Inner includes
//

#  include "PCMPremeditations.h"

#  include "PCMException.h"

#  include "PCMLogger.h"

#  include "PCMPointer.h"

//
// Outer includes
//

#  include <pcapi.h>

//
// Scripting bind includes (for Squirrel)
//

#  include <squirrel/squirrel.h>
#  include <squirrel/sqstdio.h>
#  include <squirrel/sqstdaux.h>
#  include <squirrel/sqplus.h>

namespace ParCompMark
{

  class Context
  {

        //
        // Unit test class
        //
#  ifdef PARCOMPMARK_TEST
        friend class ParCompMarkTest::TestContext;
#  endif

        //
        // Scripting binding (for Squirrel)
        //



   public:static void squirrelGlue()
        {
         ::SqPlus::SQClassDef < Context > (_T("Context")).func(&Context::setProcesses,
                                                                _T("setProcesses")).func(&Context::setContextTypeSq,
                                                                                         _T("setContextTypeSq")).
                func(&Context::getContextTypeSq, _T("getContextTypeSq")).func(&Context::getUseGLFrameletEXT,
                                                                          _T("getUseGLFrameletEXT")).
                func(&Context::setUseGLFrameletEXT, _T("setUseGLFrameletEXT")).func(&Context::getContextType,
                                                                                 _T("getContextType")).
                func(&Context::setContextType, _T("setContextType")).func(&Context::getFrameWidth,
                                                                        _T("getFrameWidth")).
                func(&Context::setFrameWidth, _T("setFrameWidth")).func(&Context::getFrameHeight,
                                                                        _T("getFrameHeight")).
                func(&Context::setFrameHeight, _T("setFrameHeight")).func(&Context::getColourFormat,
                                                                        _T("getColourFormat")).
                func(&Context::setColourFormat, _T("setColourFormat")).func(&Context::getDepthFormat,
                                                                         _T("getDepthFormat")).
                func(&Context::setDepthFormat, _T("setDepthFormat")).func(&Context::getCompositeType,
                                                                        _T("getCompositeType")).
                func(&Context::setCompositeType, _T("setCompositeType")).func(&Context::getCompressionHint,
                                                                          _T("getCompressionHint")).
                func(&Context::setCompressionHint, _T("setCompressionHint")).func(&Context::getRetainOutputCount,
                                                                                _T("getRetainOutputCount")).
                func(&Context::setRetainOutputCount,
                  _T("setRetainOutputCount")).func(&Context::getVolatileFrameletCount,
                                                  _T("getVolatileFrameletCount")).
                func(&Context::setVolatileFrameletCount, _T("setVolatileFrameletCount")).func(&Context::getOutputDepth,
                                                                                          _T("getOutputDepth")).
                func(&Context::setOutputDepth, _T("setOutputDepth")).func(&Context::getProcessIndex,
                                                                        _T("getProcessIndex")).
                func(&Context::setProcessIndex, _T("setProcessIndex")).func(&Context::getNetworkID,
                                                                         _T("getNetworkID")).
                func(&Context::setNetworkID, _T("setNetworkID")).enumInt(Context::MASTER,
                                                                         _T("MASTER")).enumInt(Context::SLAVE,
                                                                                           _T("SLAVE"));
        }


        //
        // Enumerations
        //

   public:

        enum ContextType
        {

         MASTER = 0,

         SLAVE = 1
        };

        //
        // Typedefs
        //

   public:

        typedef Pointer < Context,
        DummyLock > Pointer;

        //
        // Variables
        //



   protected:

        int mID;

        bool mUseGLFrameletEXT;

        ContextType mContextType;

        PCid mFrameID;

        PCint mFrameWidth;

        PCint mFrameHeight;

        PCint mColourFormat;

        PCint mDepthFormat;

        PCint mPixelFormat;

        PCint mCompositeType;

        PCint mCompressionHint;

        PCint mRetainOutputCount;

        PCint mVolatileFrameletCount;

        bool mOutputDepth;

        PCstring *mProcesses;

        PCint mProcessCount;

        int mProcessIndex;

        PCint mHostIndex;

        PCint mNetworkID;

        PCcontext mContext;

        Process *mParent;

        bool mInitialized;


        //
        // Constructors & destructor
        //



   public:

        Context();

        Context(Process * parent);

        virtual ~ Context();


        //
        // Getters & setters
        //



   public:

        const int &getID() const;

        void setID(const int &id);

        bool & getUseGLFrameletEXT();

        void setUseGLFrameletEXT(const bool useglframeletext);

        Context::ContextType & getContextType();

        void setContextType(const Context::ContextType & contexttype);

        PCid & getFrameID();

        PCint & getFrameWidth();

        void setFrameWidth(const PCint framewidth);

        PCint & getFrameHeight();

        void setFrameHeight(const PCint frameheight);

        PCint & getColourFormat();

        void setColourFormat(const PCint colourformat);

        PCint & getDepthFormat();

        void setDepthFormat(const PCint depthformat);

        const PCint & getPixelFormat() const;

        PCint & getCompositeType();

        void setCompositeType(const PCint compositetype);

        PCint & getCompressionHint();

        void setCompressionHint(const PCint compressionhint);

        PCint & getRetainOutputCount();

        void setRetainOutputCount(const PCint retainoutputcount);

        PCint & getVolatileFrameletCount();

        void setVolatileFrameletCount(const PCint volatileframeletcount);

        bool & getOutputDepth();

        void setOutputDepth(const bool outputdepth);

        PCstring *getProcesses() const;

        const PCint & getProcessCount() const;

        int &getProcessIndex();

        void setProcessIndex(const int processindex);

        const PCint & getHostIndex() const;

        PCint & getNetworkID();

        void setNetworkID(const PCint networkid);

        const PCcontext & getContext() const;

        Process *getParent();

        const bool & getInitialized() const;


        //
        // Methods
        //



   public:

        virtual void setProcesses(const char *processList);

        virtual void initialize();

        virtual void finalize();

        virtual void setContextTypeSq(const int contextType);

        virtual int getContextTypeSq();


  };

  //
  // Include header implementation
  //

#  include "PCMContext_impl.h"

}

// Declare Context class (and its enums) for SqPlus binding
DECLARE_INSTANCE_TYPE_NAME(ParCompMark::Context, Context);

DECLARE_INSTANCE_TYPE_NAME(ParCompMark::Context::ContextType, Context::ContextType);

#endif

© Copyright - 2006 (IT)² ParCompMark Dev. Team