TimeRang.h

Go to the documentation of this file.

// BC  4/25/2003  \Bob105\Include\TimeRang.h

#define __TIMERANG_H

#ifndef __DATATYPE_H
#include "DataType.h"
#endif
#ifndef __HASHTIME_H
#include "HashTime.h"
#endif
#include <afxtempl.h>

#define NEVER   TimeRange( TimeRange::RT_NEVER )
#define FOREVER TimeRange( TimeRange::RT_FOREVER )

class TimeRange {
public:
   Time m_start, m_end;

   enum RangeType { RT_NEVER, RT_FOREVER };
   
   TimeRange()
   {
      SetNever();
   }
   TimeRange( RangeType rt )
   {
      switch (rt) {
         case RT_NEVER:
            SetNever();
            return;
         case RT_FOREVER:
            SetForever();
            return;
      }
   }
   TimeRange( Time time )
   {
      m_start = time;
      m_end = time;
   }
   TimeRange( const TimeRange &other )
   {
      m_start = other.m_start;
      m_end = other.m_end;
   }
   TimeRange( Time start, Time end )
   {
      m_start = start;
      m_end = end;
   }
   ~TimeRange() {}

   TimeRange &operator = ( const TimeRange &other )
   {
      m_start = other.m_start;
      m_end = other.m_end;
      return *this;
   }
   void Set( Time start, Time end )
   {
      m_start = start;
      m_end = end;
   }
   void SetNever()
   {
      m_start = MAXTIME;
      m_end = -MAXTIME;
   }
   void SetForever()
   {
      m_start = -MAXTIME;
      m_end = MAXTIME;
   }
   Time GetLength() const 
   {
      return m_end - m_start;
   }
   BOOL IsValid()
   {
      return m_end >= m_start;
   }
   BOOL IsIntersect( const TimeRange &range ) const
   {
      return (m_end > range.m_start && m_start < range.m_end);
   }
   BOOL IsTimeInRange( Time time ) const
   { 
      return time>=m_start && time<=m_end;
   }
   BOOL IsTimeWithinRange( Time time ) const
   { 
      return time>m_start && time<m_end;
   }
   BOOL IsRangeInRange( const TimeRange &range ) const
   {
      return range.m_start>=m_start && range.m_end<=m_end;
   }
   BOOL IsActiveHere( Time time ) const
   { 
      return time>=m_start && time<m_end;
   }
   BOOL operator == ( const TimeRange &other )
   {
      return m_start==other.m_start && m_end==other.m_end;
   }
   BOOL operator != ( const TimeRange &other )
   {
      return !(*this == other);
   }
   void operator |= ( const TimeRange &other ) // union
   {
      m_start = MIN(m_start, other.m_start);
      m_end = MAX(m_end, other.m_end);
   }
   void operator |= ( Time time ) // union
   {
      m_start = MIN(m_start, time);
      m_end = MAX(m_end, time);
   }
   void operator &= ( const TimeRange &other ) // intersect
   {
      m_start = MAX(m_start, other.m_start);
      m_end = MIN(m_end, other.m_end);
      if (m_start > m_end)
         SetNever();
   }
   void operator &= ( Time time ) // intersect
   {
      if (IsTimeInRange(time)) {
         m_start = time;
         m_end = time;
      }
      else
         SetNever();
   }
   void operator += ( Time time ) // slide
   {
      m_start += time;
      if (m_end != MAXTIME)
         m_end += time;
   }
   TimeRange operator + ( Time time ) const
   {
      TimeRange result( *this );
      result += time;
      return result;
   }
   void operator -= ( Time time ) // slide
   {
      if (m_start != MINTIME)
         m_start -= time;
      m_end -= time;
   }
   TimeRange operator - ( Time time ) const
   {
      TimeRange result( *this );
      result -= time;
      return result;
   }
   void operator *= ( float n ) // scale
   {
      m_start *= n;
      m_end *= n;
   }
   TimeRange operator * ( float n ) const // scale
   {
      TimeRange result( *this );
      result *= n;
      return result;
   }
   void Union( Time time )
   {
      m_start = MIN(m_start, time);
      m_end = MAX(m_end, time);
   }
   BOOL IsInstance()
   {
      return m_start == m_end;
   }
};

class TimeLineSelection 
{
public:
   TimeRange          m_timerange;
   CArray< int, int > m_linearray;

   TimeLineSelection()
   {
   }

   TimeLineSelection( const TimeLineSelection &other )
   {
      *this = other;
   }

   TimeLineSelection( Time start, Time end )
   {
      m_timerange.m_start = start;
      m_timerange.m_end   = end;
   }

   void Clear()
   {
      m_timerange.SetNever();
      m_linearray.RemoveAll();
   }

   void operator += ( const TimeLineSelection &other ) // union
   {
      m_timerange |= other.m_timerange;
      for (int i=0; i<other.m_linearray.GetSize(); i++)
         if (!IsInSelection( other.m_linearray[i] ))
            m_linearray.Add( other.m_linearray[i] );
   }

   void operator += ( int line )
   {
      if (line>=0 && !IsInSelection( line ))
         m_linearray.Add( line );
   }

   void operator = ( const TimeLineSelection &other )
   {
      m_timerange = other.m_timerange;
      m_linearray.RemoveAll();
      for (int i=0; i<other.m_linearray.GetSize(); i++)
         m_linearray.Add( other.m_linearray[i] );
   }

   BOOL IsInSelection( int line )
   {
      for (int i=0; i<m_linearray.GetSize(); i++)
         if (m_linearray[i] == line)
            return TRUE;
      return FALSE;
   }
};

class TimeLineRect
{
public:
   TimeRange m_timerange;
   int       m_top, m_bottom;

   TimeLineRect()
   {
      m_top = BIG_INT;
      m_bottom = -BIG_INT;
   }

   TimeLineRect( Time start, Time end, int top=BIG_INT, int bottom=-BIG_INT )
   {
      m_timerange.m_start = start;
      m_timerange.m_end   = end;
      m_top               = top;
      m_bottom            = bottom;
   }

   void Clear()
   {
      m_timerange.SetNever();
      m_top = BIG_INT;
      m_bottom = -BIG_INT;
   }

   void operator |= ( const TimeLineRect &other ) // union
   {
      m_timerange |= other.m_timerange;

      m_top = MIN(m_top, other.m_top);
      m_bottom = MAX(m_bottom, other.m_bottom);
   }

   void operator |= ( const TimeLineSelection &other ) // union
   {
      m_timerange |= other.m_timerange;

      for (int i=0; i<other.m_linearray.GetSize(); i++) {
         m_top = MIN(m_top, other.m_linearray[i]);
         m_bottom = MAX(m_bottom, other.m_linearray[i]);
      }
   }
};

---