moTimer.h

Go to the documentation of this file.

/*******************************************************************************

                                moTimer.h

  ****************************************************************************
  *                                                                          *
  *   This source 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 code 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.                               *
  *                                                                          *
  *   A copy of the GNU General Public License is available on the World     *
  *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also       *
  *   obtain it by writing to the Free Software Foundation,                  *
  *   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.         *
  *                                                                          *
  ****************************************************************************

  Copyright(C) 2006 Fabricio Costa

  Authors:
  Fabricio Costa


*******************************************************************************/

#include "moTypes.h"

#ifndef __MO_TIMER_H__
#define __MO_TIMER_H__



LIBMOLDEO_API MOulong moGetTicks();


LIBMOLDEO_API MOulong moGetTicksAbsolute( bool force_real_absolute=false );


LIBMOLDEO_API MOulong moGetTicksAbsoluteStep( long step_interval=0 );

LIBMOLDEO_API MOulong moResetTicksAbsoluteStep( long reset_value=0 );




enum moTimerState {
  MO_TIMERSTATE_STOPPED,
  MO_TIMERSTATE_PLAYING,
  MO_TIMERSTATE_PAUSED
};


LIBMOLDEO_API void moStartTimer();


LIBMOLDEO_API void moSetDuration( MOulong p_timecode );


LIBMOLDEO_API MOulong moGetDuration();


LIBMOLDEO_API void moContinueTimer();


LIBMOLDEO_API void moPauseTimer();


LIBMOLDEO_API void moStopTimer();



LIBMOLDEO_API moTimerState moGetTimerState();
LIBMOLDEO_API moText moGetTimerStateStr();



LIBMOLDEO_API bool moIsTimerPaused();



LIBMOLDEO_API bool moIsTimerStopped();


LIBMOLDEO_API bool moIsTimerPlaying();


LIBMOLDEO_API bool moIsTimerStarted();




class LIBMOLDEO_API moTimerAbsolute {

  friend class moEffectState;
  public:

    moTimerAbsolute();
    moTimerAbsolute( const moTimerAbsolute &src);
    virtual ~moTimerAbsolute();

    moTimerAbsolute &operator = (const moTimerAbsolute &src);




    int LastDuration() const {
        return duration;
    }



    virtual void Start();


    void Stop() {
        on = false;
        pause_on = false;
        start_tick = 0;
        start_last = 0;
        duration = 0;
    }


    void Pause() {
        pause_on = true;
    }


    void Continue() {
        pause_on = false;
    }


    bool Started() const {
        return on;
    }


    bool Paused() const {
        return on && pause_on;
    }


    virtual void SetDuration( MOulong p_timecode );


    virtual long Duration();


    virtual moTimerState State() const;
    virtual const moText& StateToStr() {

      state_str = "unknown";

      switch(State()) {
        case MO_TIMERSTATE_PAUSED:
          state_str = "paused";
          break;
        case MO_TIMERSTATE_PLAYING:
          state_str = "playing";
          break;
        case MO_TIMERSTATE_STOPPED:
          state_str = "stopped";
          break;
      }
      return state_str;
    }

protected:
        bool on;
        bool pause_on;

        long start_tick;
        long start_last;

        long duration;

        long last_duration;
        moText state_str;
        long last_step_interval;

};



class LIBMOLDEO_API moTimer : public moTimerAbsolute {

    public:


        moTimer();

        moTimer( const moTimer& src );
        virtual ~moTimer();
        moTimer& operator=( const moTimer& src);




        virtual void Start();


        virtual void SetDuration( MOulong p_timecode );


        virtual long Duration();


        void Fix();


        void SetTimerId( long p_timerid ) {
                m_TimerId = p_timerid;
        }


        long GetTimerId() {
                return m_TimerId;
        }


        void SetObjectId( long p_objectid ) {
                m_ObjectId = p_objectid;
        }


        long GetObjectId() {
                return m_ObjectId;
        }


        void SetRelativeTimer( moTimerAbsolute* p_pRelativeTimer = NULL ) {
            m_pRelativeTimer = p_pRelativeTimer;
        }



        moTimerAbsolute* GetRelativeTimer() {
            return m_pRelativeTimer;
        }

    private:
        long m_TimerId;
        long m_ObjectId;

        moTimerAbsolute*    m_pRelativeTimer;
};


moDeclareExportedDynamicArray( moTimer*, moTimers);

#endif