Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wxTimer/timercmn.cpp change

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4528 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-11-12 19:19:38 +00:00
parent 97d3f0eee6
commit 0470b1e6fe
15 changed files with 480 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

339
src/common/timercmn.cpp
View File

@@ -1,233 +1,220 @@
/////////////////////////////////////////////////////////////////////////////
// Name: timercmn.cpp
// Name: common/timercmn.cpp
// Purpose: Common timer implementation
// Author: Julian Smart
// Modified by:
// Modified by: Vadim Zeitlin on 12.11.99 to get rid of all ifdefs
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
//#pragma implementation "timercmn.h"
#pragma implementation
#pragma implementation "timerbase.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/defs.h"
#include "wx/list.h"
#include "wx/intl.h"
#include "wx/log.h"
#endif
#include "wx/timer.h"
#if defined(__SVR4__) && !defined(__SYSV__)
#define __SYSV__
// I'm told VMS is POSIX, so should have localtime()
#if defined(__WXMSW__) || defined(__VMS__)
// configure might have found it already for us
#ifndef HAVE_LOCALTIME
#define HAVE_LOCALTIME
// TODO add test for broken compilers here if needed
#define WX_GMTOFF_IN_TM
#endif
#endif
#include <time.h>
#ifndef __WXMAC__
#include <sys/types.h>
#if defined(HAVE_GETTIMEOFDAY)
#include <sys/time.h>
#include <unistd.h>
#elif defined(HAVE_LOCALTIME)
#include <time.h>
#ifndef __WXMAC__
#include <sys/types.h> // for time_t
#endif
#elif defined(HAVE_FTIME)
#include <sys/timeb.h>
#else
#error "no function to find the current time on this system"
#endif
#if (!defined(__SC__) && !defined(__SGI__) && !defined(__GNUWIN32__) && !defined(__MWERKS__)) || defined(__MINGW32__)
#include <sys/timeb.h>
#endif
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
#if defined(__linux__) || defined(__SVR4__) || defined(__SYSV__) || defined(__SGI__) || \
defined(__ALPHA__) || defined(__GNUWIN32__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
defined(__SALFORDC__) || defined(__EMX__)
#include <sys/time.h>
#endif
// on some really old systems gettimeofday() doesn't have the second argument,
// define wxGetTimeOfDay() to hide this difference
#ifdef HAVE_GETTIMEOFDAY
#ifdef WX_GETTIMEOFDAY_NO_TZ
struct timezone;
#define wxGetTimeOfDay(tv, tz) gettimeofday(tv)
#else
#define wxGetTimeOfDay(tv, tz) gettimeofday((tv), (tz))
#endif
#endif // HAVE_GETTIMEOFDAY
#ifdef __MINGW32__
#include "windows.h"
#endif
// ============================================================================
// implementation
// ============================================================================
#if defined(__SUN__) || defined(__OSF__) || defined(__FreeBSD__)
// At least on Sun, ftime is undeclared.
// Need to be verified on other platforms.
extern "C" int ftime(struct timeb *tp);
//extern "C" int gettimeofday(struct timeval *tp, void *);
// extern "C" time_t time(time_t);
// #include <sys/timeb.h>
#if defined(__SVR4__) && !defined(__ALPHA__)
// ditto for gettimeofday on Solaris 2.x.
extern "C" int gettimeofday(struct timeval *tp, void *);
#endif
#endif
// ----------------------------------------------------------------------------
// wxStopWatch
// ----------------------------------------------------------------------------
/*
* Timer functions
*
*/
long wxStartTime = 0;
void wxStartTimer(void)
void wxStopWatch::Start(long t)
{
wxStartTime=wxGetCurrentMTime();
m_t0 = wxGetCurrentMTime() - t;
m_pause = 0;
}
long wxStopWatch::Time() const
{
return m_pause ? m_pause : GetElapsedTime();
}
// ----------------------------------------------------------------------------
// old timer functions superceded by wxStopWatch
// ----------------------------------------------------------------------------
static long wxStartTime = 0;
// starts the global timer
void wxStartTimer()
{
wxStartTime = wxGetCurrentMTime();
}
// Returns elapsed time in milliseconds
long wxGetElapsedTime(bool resetTimer)
{
long oldTime = wxStartTime;
long newTime=wxGetCurrentMTime();
long oldTime = wxStartTime;
long newTime = wxGetCurrentMTime();
if (resetTimer) wxStartTime = newTime;
return newTime - oldTime;
if ( resetTimer )
wxStartTime = newTime;
return newTime - oldTime;
}
// Get number of seconds since 00:00:00 GMT, Jan 1st 1970.
long wxGetCurrentTime(void)
long wxGetCurrentTime()
{
return wxGetCurrentMTime()/1000;
return wxGetCurrentMTime() / 1000;
}
// ----------------------------------------------------------------------------
// the functions to get the current time and timezone info
// ----------------------------------------------------------------------------
// return GMT time in millisecond
long wxGetCurrentMTime()
{
#if defined(__xlC__) || defined(__AIX__) || defined(__SVR4__) || defined(__SYSV__) || \
(defined(__GNUWIN32__) && !defined(__MINGW32__)) // || defined(__AIXV3__)
struct timeval tp;
#if defined(__SYSV__) || (defined (__GNUWIN32__) && !defined (__MINGW32__))
gettimeofday(&tp, (struct timezone *)NULL);
#if defined(HAVE_LOCALTIME)
time_t t0 = time(&t0);
if ( t0 != (time_t)-1 )
{
struct tm *tp = localtime(&t0);
if ( tp )
{
return 1000*(60*(60*tp->tm_hour+tp->tm_min)+tp->tm_sec);
}
}
#elif defined(HAVE_GETTIMEOFDAY)
struct timeval tp;
if ( wxGetTimeOfDay(&tp, (struct timezone *)NULL) != -1 )
{
return (1000*tp.tv_sec + tp.tv_usec / 1000);
}
#elif defined(HAVE_FTIME)
struct timeb tp;
if ( ftime(&tp) == 0 )
{
return (1000*tp.time + tp.millitm);
}
#else
gettimeofday(&tp);
#endif
return (1000*tp.tv_sec + tp.tv_usec / 1000);
#elif (defined(__SC__) || defined(__SGI__) || defined(___BSDI__) || defined(__ALPHA__) || \
defined(__MINGW32__)|| defined(__MWERKS__) || defined(__FreeBSD__))
time_t t0;
struct tm *tp;
time(&t0);
tp = localtime(&t0);
return 1000*(60*(60*tp->tm_hour+tp->tm_min)+tp->tm_sec);
#else
struct timeb tp;
ftime(&tp);
return (1000*tp.time + tp.millitm);
#error "no function to find the current time on this system"
#endif
wxLogSysError(_("Failed to get the system time"));
return -1;
}
//---------------
// wxChrono class
// This class encapsulates the above fonctions,
// such that several wxChrono can be created
// simultaneously
wxChrono::wxChrono()
{
Start();
}
void wxChrono::Start(long t)
{
m_t0=wxGetCurrentMTime()-t;
m_pause=0;
}
void wxChrono::Pause()
{
m_pause=wxGetCurrentMTime()-m_t0;
}
void wxChrono::Resume()
{
m_t0=wxGetCurrentMTime()-m_pause;
m_pause=0;
}
long wxChrono::Time()
{
if (m_pause) return m_pause;
return wxGetCurrentMTime()-m_t0;
}
// EXPERIMENTAL: comment this out if it doesn't compile.
#if !defined( __VMS__ ) || ( __VMS_VER >= 70000000 )
bool wxGetLocalTime(long *timeZone, int *dstObserved)
{
#if defined(__MINGW32__)
time_t t0;
struct tm *tp;
time(&t0);
tp = localtime(&t0);
# if __GNUC__ == 2 && __GNUC_MINOR__ <= 8
// gcc 2.8.x or earlier
timeb tz;
ftime(& tz);
*timeZone = tz._timezone;
# else
// egcs or gcc 2.95
*timeZone = _timezone; // tp->tm_gmtoff; // ???
# endif
*dstObserved = tp->tm_isdst;
#if defined(HAVE_LOCALTIME) && defined(WX_GMTOFF_IN_TM)
time_t t0 = time(&t0);
if ( t0 != (time_t)-1 )
{
struct tm *tm = localtime(&t0);
if ( tm )
{
*timeZone = tm->tm_gmtoff;
*dstObserved = tm->tm_isdst;
return TRUE;
}
}
#elif defined(HAVE_GETTIMEOFDAY) && !defined(WX_GETTIMEOFDAY_NO_TZ)
struct timeval tp;
struct timezone tz;
if ( gettimeofday(&tp, &tz) != -1 )
{
*timeZone = 60*tz.tz_minuteswest;
*dstObserved = tz.tz_dsttime;
return TRUE;
}
#elif defined(HAVE_FTIME)
struct timeb tb;
if ( ftime(&tb) == 0 )
{
*timeZone = 60*tb.timezone;
*dstObserved = tb.dstflag;
}
#else
// not mingw32...
#if (((defined(__SYSV__) && !defined(__HPUX__)) || defined(__MSDOS__) || defined(__WXMSW__) || defined(__WXPM__)) \
&& !defined(__GNUWIN32__) && !defined(__MWERKS__) )
# if defined(__BORLANDC__)
/* Borland uses underscores */
*timeZone = _timezone;
*dstObserved = _daylight;
# elif defined(__SALFORDC__)
*timeZone = _timezone;
*dstObserved = daylight;
# elif defined(__VISAGECPP__)
*timeZone = _timezone;
*dstObserved = daylight;
# else
*timeZone = timezone;
*dstObserved = daylight;
# endif
#elif defined(__xlC__) || defined(__AIX__) || defined(__SVR4__) || \
defined(__SYSV__) || defined(__MWERKS__) || (defined(__GNUWIN32__) && \
!defined(__MINGW32__))\
|| defined( __VMS__ ) // || defined(__AIXV3__)
# if defined(__SYSV__) || (defined(__GNUWIN32__) && !defined(__MINGW32))
# ifndef __MWERKS__
struct timeval tp;
# endif
struct timezone tz;
gettimeofday(&tp, &tz);
*timeZone = 60*(tz.tz_minuteswest);
*dstObserved = tz.tz_dsttime;
# else
time_t t0;
struct tm *tp;
time(&t0);
tp = localtime(&t0);
# ifndef __MWERKS__
*timeZone = tp->tm_gmtoff; // ???
# else
*timeZone = 0 ;
# endif
*dstObserved = tp->tm_isdst;
// special hacks for known compilers - I wonder if this is still needed,
// i.e. if there are any of them which don't support localtime()? (VZ)
#if defined(__BORLANDC__)
*timeZone = _timezone;
*dstObserved = _daylight;
#elif defined(__SALFORDC__)
*timeZone = _timezone;
*dstObserved = daylight;
#elif defined(__VISAGECPP__)
*timeZone = _timezone;
*dstObserved = daylight;
#else
wxFAIL_MSG(_T("wxGetLocalTime() not implemented"));
#endif // compiler
#endif
#elif defined(__WXSTUBS__)
return FALSE;
#else
// #error wxGetLocalTime not implemented.
struct timeval tp;
struct timezone tz;
gettimeofday(&tp, &tz);
*timeZone = 60*(tz.tz_minuteswest);
*dstObserved = tz.tz_dsttime;
#endif
#endif
// __MINGW32__
return TRUE;
return FALSE;
}
#endif

15
src/gtk/timer.cpp
View File

@@ -85,7 +85,7 @@ static gint timeout_callback( gpointer data )
GDK_THREADS_LEAVE ();
#endif
if (timer->OneShot())
if ( timer->IsOneShot() )
return FALSE;
return TRUE;
@@ -94,25 +94,20 @@ static gint timeout_callback( gpointer data )
wxTimer::wxTimer()
{
m_tag = -1;
m_time = 1000;
m_milli = 1000;
m_oneShot = FALSE;
}
wxTimer::~wxTimer()
{
Stop();
wxTimer::Stop();
}
bool wxTimer::Start( int millisecs, bool oneShot )
{
if (millisecs != -1)
{
m_time = millisecs;
}
(void)wxTimerBase::Start(millisecs, oneShot);
m_oneShot = oneShot;
m_tag = gtk_timeout_add( millisecs, timeout_callback, this );
m_tag = gtk_timeout_add( m_milli, timeout_callback, this );
return TRUE;
}

15
src/gtk1/timer.cpp
View File

@@ -85,7 +85,7 @@ static gint timeout_callback( gpointer data )
GDK_THREADS_LEAVE ();
#endif
if (timer->OneShot())
if ( timer->IsOneShot() )
return FALSE;
return TRUE;
@@ -94,25 +94,20 @@ static gint timeout_callback( gpointer data )
wxTimer::wxTimer()
{
m_tag = -1;
m_time = 1000;
m_milli = 1000;
m_oneShot = FALSE;
}
wxTimer::~wxTimer()
{
Stop();
wxTimer::Stop();
}
bool wxTimer::Start( int millisecs, bool oneShot )
{
if (millisecs != -1)
{
m_time = millisecs;
}
(void)wxTimerBase::Start(millisecs, oneShot);
m_oneShot = oneShot;
m_tag = gtk_timeout_add( millisecs, timeout_callback, this );
m_tag = gtk_timeout_add( m_milli, timeout_callback, this );
return TRUE;
}

29
src/motif/timer.cpp
View File

@@ -37,24 +37,24 @@ void wxTimerCallback (wxTimer * timer)
return; // Avoid to process spurious timer events
if (!timer->m_oneShot)
timer->m_id = XtAppAddTimeOut ((XtAppContext) wxTheApp->GetAppContext(), timer->m_milli,
(XtTimerCallbackProc) wxTimerCallback, (XtPointer) timer);
timer->m_id = XtAppAddTimeOut((XtAppContext) wxTheApp->GetAppContext(),
timer->m_milli,
(XtTimerCallbackProc) wxTimerCallback,
(XtPointer) timer);
else
timer->m_id = 0;
timer->Notify ();
timer->Notify();
}
wxTimer::wxTimer()
{
m_id = 0;
m_milli = 0 ;
m_id = 0;
m_oneShot = FALSE;
}
wxTimer::~wxTimer()
{
Stop();
wxTimer::Stop();
wxTimerList.DeleteObject(this);
}
@@ -62,20 +62,15 @@ bool wxTimer::Start(int milliseconds, bool mode)
{
Stop();
m_oneShot = mode;
if (milliseconds < 0)
milliseconds = m_lastMilli;
if (milliseconds <= 0)
return FALSE;
m_lastMilli = m_milli = milliseconds;
(void)wxTimerBase::Start(milliseconds, mode);
if (!wxTimerList.Find((long)this))
wxTimerList.Append((long)this, this);
m_id = XtAppAddTimeOut ((XtAppContext) wxTheApp->GetAppContext(), milliseconds,
(XtTimerCallbackProc) wxTimerCallback, (XtPointer) this);
m_id = XtAppAddTimeOut((XtAppContext) wxTheApp->GetAppContext(),
m_milli,
(XtTimerCallbackProc) wxTimerCallback,
(XtPointer) this);
return TRUE;
}

52
src/msw/timer.cpp
View File

@@ -20,27 +20,19 @@
#pragma hdrstop
#endif
#include "wx/window.h"
#include "wx/msw/private.h"
#ifndef WX_PRECOMP
#include "wx/setup.h"
#include "wx/window.h"
#include "wx/list.h"
#include "wx/event.h"
#include "wx/app.h"
#include "wx/intl.h"
#include "wx/log.h"
#endif
#include "wx/intl.h"
#include "wx/log.h"
#include "wx/timer.h"
#include <time.h>
#include <sys/types.h>
#if !defined(__SC__) && !defined(__GNUWIN32__) && !defined(__MWERKS__)
#include <sys/timeb.h>
#endif
#include "wx/msw/private.h"
// ----------------------------------------------------------------------------
// private functions
@@ -73,37 +65,31 @@ UINT WINAPI _EXPORT wxTimerProc(HWND hwnd, WORD, int idTimer, DWORD);
wxTimer::wxTimer()
{
milli = 0;
lastMilli = -1;
id = 0;
m_id = 0;
}
wxTimer::~wxTimer()
{
Stop();
wxTimer::Stop();
wxTimerList.DeleteObject(this);
}
bool wxTimer::Start(int milliseconds, bool mode)
bool wxTimer::Start(int milliseconds, bool oneShot)
{
oneShot = mode;
if (milliseconds < 0)
milliseconds = lastMilli;
(void)wxTimerBase::Start(milliseconds, oneShot);
wxCHECK_MSG( milliseconds > 0, FALSE, wxT("invalid value for timer timeour") );
lastMilli = milli = milliseconds;
wxCHECK_MSG( m_milli > 0, FALSE, wxT("invalid value for timer timeour") );
wxTimerList.DeleteObject(this);
TIMERPROC wxTimerProcInst = (TIMERPROC)
MakeProcInstance((FARPROC)wxTimerProc, wxGetInstance());
id = SetTimer(NULL, (UINT)(id ? id : 1),
(UINT)milliseconds, wxTimerProcInst);
if (id > 0)
m_id = SetTimer(NULL, (UINT)(m_id ? m_id : 1),
(UINT)milliseconds, wxTimerProcInst);
if ( m_id > 0 )
{
wxTimerList.Append(id, this);
wxTimerList.Append(m_id, this);
return TRUE;
}
@@ -117,13 +103,13 @@ bool wxTimer::Start(int milliseconds, bool mode)
void wxTimer::Stop()
{
if ( id )
if ( m_id )
{
KillTimer(NULL, (UINT)id);
KillTimer(NULL, (UINT)m_id);
wxTimerList.DeleteObject(this);
}
id = 0;
milli = 0;
m_id = 0;
}
// ----------------------------------------------------------------------------
@@ -133,10 +119,10 @@ void wxTimer::Stop()
void wxProcessTimer(wxTimer& timer)
{
// Avoid to process spurious timer events
if ( timer.id == 0)
if ( timer.m_id == 0)
return;
if ( timer.oneShot )
if ( timer.IsOneShot() )
timer.Stop();
timer.Notify();