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

Search this page:

PCMProcess_impl.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.


 //
 // Getters & setters
 //

inline Process::ContextList & Process::getContexts()
{
  return mContexts;
}

 /*-------------------------------------------------------------------------*/

inline Process::ProcessType & Process::getProcessType()
{
  return mProcessType;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setProcessType(const Process::ProcessType & processtype)
{
  mProcessType = processtype;
}

 /*-------------------------------------------------------------------------*/

inline Node *Process::getParent() const
{
  return mParent;
}

 /*-------------------------------------------------------------------------*/

inline GLXRenderWindow::Pointer & Process::getRenderWindow()
{
  return mRenderWindow;
}

 /*-------------------------------------------------------------------------*/

inline OpenGLRenderingEngine::Pointer & Process::getRenderingEngine()
{
  return mRenderingEngine;
}

 /*-------------------------------------------------------------------------*/

inline char *Process::getInitProcCode()
{
  return mInitProcCode;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setInitProcCode(const char *initproccode)
{
  mInitProcCode = new char[strlen(initproccode) + 1];

  strcpy(mInitProcCode, (char *) initproccode);
}

 /*-------------------------------------------------------------------------*/

inline char *Process::getRunningProcCode()
{
  return mRunningProcCode;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setRunningProcCode(const char *runningproccode)
{
  mRunningProcCode = new char[strlen(runningproccode) + 1];

  strcpy(mRunningProcCode, (char *) runningproccode);
}

 /*-------------------------------------------------------------------------*/

inline Buffer::Pointer & Process::getBuffer()
{
  return mBuffer;
}

 /*-------------------------------------------------------------------------*/

inline const bool & Process::getInitialized() const
{
  return mInitialized;
}

 /*-------------------------------------------------------------------------*/

inline PCuint & Process::getSortOrder()
{
  return mSortOrder;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setSortOrder(const PCuint sortorder)
{
  mSortOrder = sortorder;
}

 /*-------------------------------------------------------------------------*/

inline PCid & Process::getStopID()
{
  return mStopID;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setStopID(const PCid stopid)
{
  mStopID = stopid;
}

 /*-------------------------------------------------------------------------*/

inline bool & Process::getOperate()
{
  return mOperate;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setOperate(const bool operate)
{
  mOperate = operate;
}

 /*-------------------------------------------------------------------------*/

inline bool & Process::getDisplayOutput()
{
  return mDisplayOutput;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setDisplayOutput(const bool displayoutput)
{
  mDisplayOutput = displayoutput;
}

 /*-------------------------------------------------------------------------*/

inline bool & Process::getGatherStatistics()
{
  return mGatherStatistics;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setGatherStatistics(const bool gatherstatistics)
{
  mGatherStatistics = gatherstatistics;
}

 /*-------------------------------------------------------------------------*/

inline const u32 & Process::getFrameNumber() const
{
  return mFrameNumber;
}

 /*-------------------------------------------------------------------------*/

inline const Real & Process::getFrameTime() const
{
  return mFrameTime;
}

 /*-------------------------------------------------------------------------*/

inline const Real & Process::getStartTime() const
{
  return mStartTime;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setStartTime(const Real & starttime)
{
  mStartTime = starttime;
}

 /*-------------------------------------------------------------------------*/

inline const bool & Process::getStop() const
{
  return mStop;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setStop(const bool & stop)
{
  mStop = stop;
}

 /*-------------------------------------------------------------------------*/

inline const bool & Process::getStopAble() const
{
  return mStopAble;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setStopAble(const bool & stopable)
{
  mStopAble = stopable;
}

 /*-------------------------------------------------------------------------*/

inline const bool & Process::getCountedStop() const
{
  return mCountedStop;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setCountedStop(const bool & countedstop)
{
  mCountedStop = countedstop;
}

 /*-------------------------------------------------------------------------*/

inline OutputNode::Pointer & Process::getOutputDocument()
{
  return mOutputDocument;
}

 /*-------------------------------------------------------------------------*/

inline const bool & Process::getShowFrameletIcon() const
{
  return mShowFrameletIcon;
}

 /*-------------------------------------------------------------------------*/

inline int &Process::getExportFrameStep()
{
  return mExportFrameStep;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setExportFrameStep(const int exportframestep)
{
  mExportFrameStep = exportframestep;
}

 /*-------------------------------------------------------------------------*/

inline char *Process::getFrameFilenamePattern()
{
  return mFrameFilenamePattern;
}

 /*-------------------------------------------------------------------------*/

inline void Process::setFrameFilenamePattern(const char *framefilenamepattern)
{
  mFrameFilenamePattern = strdup(framefilenamepattern);
}

 /*-------------------------------------------------------------------------*/

 //
 // Methods
 //

inline void Process::setProcessTypeSq(const int processType)
{
  mProcessType = ProcessType(processType);
}

 /*----------------------------------------------------------------------*/

inline int Process::getProcessTypeSq()
{
  return mProcessType;
}

 /*----------------------------------------------------------------------*/

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