trialevent.h

Go to the documentation of this file.

//
// Copyright (c) 1999-2004 California Institute of Technology
// Copyright (c) 2004-2007 University of Southern California
// Rob Peters <rjpeters at usc dot edu>
//
// created: Fri Jun 25 12:45:05 1999
// commit: $Id: trialevent.h 10065 2007-04-12 05:54:56Z rjpeters $
// $HeadURL: file:///lab/rjpeters/svnrepo/code/trunk/groovx/src/visx/trialevent.h $
//
// --------------------------------------------------------------------
//
// This file is part of GroovX.
//   [http://ilab.usc.edu/rjpeters/groovx/]
//
// GroovX 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.
//
// GroovX 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 GroovX; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//

#ifndef GROOVX_VISX_TRIALEVENT_H_UTC20050626084015_DEFINED
#define GROOVX_VISX_TRIALEVENT_H_UTC20050626084015_DEFINED

#include "io/io.h"

#include "nub/ref.h"
#include "nub/timer.h"

#include "tcl-io/tclprocwrapper.h"

#include <vector>

namespace rutz
{
  template <class T> class fwd_iter;
  template <class T> class shared_ptr;
}

namespace nub
{
  class scheduler;
}

class output_file;
class Trial;

//  #######################################################
//  =======================================================


class TrialEvent : public io::serializable
{
protected:
  TrialEvent(unsigned int msec);

public:
  virtual ~TrialEvent() throw();

  virtual void read_from(io::reader& reader);
  virtual void write_to(io::writer& writer) const;

  unsigned int getDelay() const { return itsRequestedDelay; }

  void setDelay(unsigned int msec) { itsRequestedDelay = msec; }

  bool is_pending() const { return itsTimer.is_pending(); }


  unsigned int schedule(rutz::shared_ptr<nub::scheduler> s,
                        Trial& trial,
                        unsigned int minimum_msec = 0);


  void cancel();


  virtual void invoke(Trial& trial) = 0;

private:
  void invokeTemplate();

  TrialEvent(const TrialEvent&);
  TrialEvent& operator=(const TrialEvent&);

  nub::timer itsTimer;
  unsigned int itsRequestedDelay;
  Trial* itsTrial;

  // Diagnostic stuff
  mutable double itsEstimatedOffset;
  mutable double itsTotalOffset;
  mutable double itsTotalError;
  mutable int itsInvokeCount;
};



//  #######################################################
//  =======================================================


class NullTrialEvent : public TrialEvent
{
protected:
  NullTrialEvent(unsigned int msec = 0);

  virtual ~NullTrialEvent() throw();

  virtual void invoke(Trial&);

public:
  static NullTrialEvent* make() { return new NullTrialEvent; }
};

//  #######################################################
//  =======================================================

class TrialMemFuncEvent : public TrialEvent
{
public:
  typedef void (Trial::* CallbackType)();

  virtual rutz::fstring obj_typename() const;

  static TrialMemFuncEvent* make(CallbackType callback,
                                 const rutz::fstring& type,
                                 unsigned int msec = 0);

protected:
  TrialMemFuncEvent(CallbackType callback,
                    const rutz::fstring& type,
                    unsigned int msec = 0);

  virtual ~TrialMemFuncEvent() throw();

  virtual void invoke(Trial& trial);

private:
  CallbackType itsCallback;
  rutz::fstring itsTypename;
};

//  #######################################################
//  =======================================================

//  Here's a set of creator functions that return different
//  TrialMemFuncEvent objects bound to different Trial member functions.

TrialEvent* makeAbortTrialEvent();
TrialEvent* makeDrawEvent();
TrialEvent* makeRenderEvent();
TrialEvent* makeEndTrialEvent();
TrialEvent* makeNextNodeEvent();
TrialEvent* makeAllowResponsesEvent();
TrialEvent* makeDenyResponsesEvent();
TrialEvent* makeUndrawEvent();
TrialEvent* makeRenderBackEvent();
TrialEvent* makeRenderFrontEvent();
TrialEvent* makeSwapBuffersEvent();
TrialEvent* makeClearBufferEvent();
TrialEvent* makeFinishDrawingEvent();


//  #######################################################
//  =======================================================

class FileWriteEvent : public TrialEvent
{
protected:
  FileWriteEvent(unsigned int msec = 0);

  virtual ~FileWriteEvent() throw();

  virtual void invoke(Trial& trial);

public:
  static FileWriteEvent* make() { return new FileWriteEvent; }

  virtual void read_from(io::reader& reader);
  virtual void write_to(io::writer& writer) const;

  int getByte() const;

  void setByte(int b);

  nub::ref<output_file> getFile() const;

  void setFile(nub::ref<output_file> file);

private:
  nub::ref<output_file> itsFile;
  int itsByte;
};

//  #######################################################
//  =======================================================

class GenericEvent : public TrialEvent
{
protected:
  GenericEvent(unsigned int msec = 0);

  virtual ~GenericEvent() throw();

  virtual void invoke(Trial& trial);

public:
  static GenericEvent* make() { return new GenericEvent; }

  virtual void read_from(io::reader& reader);
  virtual void write_to(io::writer& writer) const;

  rutz::fstring getCallback() const;

  void setCallback(const rutz::fstring& script);

private:
  nub::ref<tcl::ProcWrapper> itsCallback;
};

//  #######################################################
//  =======================================================


class MultiEvent : public TrialEvent
{
protected:
  MultiEvent(unsigned int msec = 0);

  virtual ~MultiEvent() throw();

  virtual void invoke(Trial& trial);

public:
  static MultiEvent* make() { return new MultiEvent; }

  virtual void read_from(io::reader& reader);
  virtual void write_to(io::writer& writer) const;

  rutz::fwd_iter<const nub::ref<TrialEvent> > getEvents() const;

  unsigned int addEvent(nub::ref<TrialEvent> event);

  void eraseEventAt(unsigned int index);

  void clearEvents();

private:
  std::vector<nub::ref<TrialEvent> > itsEvents;
};

static const char __attribute__((used)) vcid_groovx_visx_trialevent_h_utc20050626084015[] = "$Id: trialevent.h 10065 2007-04-12 05:54:56Z rjpeters $ $HeadURL: file:
#endif // !GROOVX_VISX_TRIALEVENT_H_UTC20050626084015_DEFINED

---

The software described here is Copyright (c) 1998-2005, Rob Peters.
This page was generated Wed Dec 3 06:49:42 2008 by Doxygen version 1.5.5.