AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests 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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
configure vendored
View File

@ -11125,7 +11125,7 @@ fi
if test "$wxUSE_TIMEDATE" = "yes"; then
for ac_func in gettimeofday localtime ftime
for ac_func in localtime gettimeofday ftime
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
echo "configure:11132: checking for $ac_func" >&5
@ -11174,16 +11174,57 @@ if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
cat >> confdefs.h <<EOF
#define $ac_tr_func 1
EOF
break
else
echo "$ac_t""no" 1>&6
fi
done
if test "$ac_cv_func_gettimeofday" = "yes"; then
if test "$ac_cv_func_localtime" = "yes"; then
echo $ac_n "checking for tm_gmtoff in struct tm""... $ac_c" 1>&6
echo "configure:11187: checking for tm_gmtoff in struct tm" >&5
if eval "test \"`echo '$''{'wx_cv_struct_tm_has_gmtoff'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
#line 11193 "configure"
#include "confdefs.h"
#include <time.h>
int main() {
struct tm tm;
tm.tm_gmtoff++;
; return 0; }
EOF
if { (eval echo configure:11205: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
wx_cv_struct_tm_has_gmtoff=yes,
cat >> confdefs.h <<\EOF
#define WX_GMTOFF_IN_TM 1
EOF
else
echo "configure: failed program was:" >&5
cat conftest.$ac_ext >&5
rm -rf conftest*
wx_cv_struct_tm_has_gmtoff=no
fi
rm -f conftest*
fi
echo "$ac_t""$wx_cv_struct_tm_has_gmtoff" 1>&6
elif test "$ac_cv_func_gettimeofday" = "yes"; then
echo $ac_n "checking whether gettimeofday takes two arguments""... $ac_c" 1>&6
echo "configure:11187: checking whether gettimeofday takes two arguments" >&5
echo "configure:11228: checking whether gettimeofday takes two arguments" >&5
if eval "test \"`echo '$''{'wx_cv_func_gettimeofday_has_2_args'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
@ -11198,7 +11239,7 @@ cross_compiling=$ac_cv_prog_cxx_cross
cat > conftest.$ac_ext <<EOF
#line 11202 "configure"
#line 11243 "configure"
#include "confdefs.h"
#include <sys/time.h>
@ -11212,7 +11253,7 @@ int main() {
; return 0; }
EOF
if { (eval echo configure:11216: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
if { (eval echo configure:11257: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
wx_cv_func_gettimeofday_has_2_args=yes
else
@ -11220,7 +11261,7 @@ else
cat conftest.$ac_ext >&5
rm -rf conftest*
cat > conftest.$ac_ext <<EOF
#line 11224 "configure"
#line 11265 "configure"
#include "confdefs.h"
#include <sys/time.h>
@ -11233,7 +11274,7 @@ int main() {
; return 0; }
EOF
if { (eval echo configure:11237: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
if { (eval echo configure:11278: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
wx_cv_func_gettimeofday_has_2_args=no
else
@ -11277,12 +11318,12 @@ fi
if test "$wxUSE_SOCKETS" = "yes"; then
echo $ac_n "checking for socket""... $ac_c" 1>&6
echo "configure:11281: checking for socket" >&5
echo "configure:11322: checking for socket" >&5
if eval "test \"`echo '$''{'ac_cv_func_socket'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
#line 11286 "configure"
#line 11327 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char socket(); below. */
@ -11305,7 +11346,7 @@ socket();
; return 0; }
EOF
if { (eval echo configure:11309: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
if { (eval echo configure:11350: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_socket=yes"
else
@ -11323,7 +11364,7 @@ if eval "test \"`echo '$ac_cv_func_'socket`\" = yes"; then
else
echo "$ac_t""no" 1>&6
echo $ac_n "checking for socket in -lsocket""... $ac_c" 1>&6
echo "configure:11327: checking for socket in -lsocket" >&5
echo "configure:11368: checking for socket in -lsocket" >&5
ac_lib_var=`echo socket'_'socket | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
@ -11331,7 +11372,7 @@ else
ac_save_LIBS="$LIBS"
LIBS="-lsocket $LIBS"
cat > conftest.$ac_ext <<EOF
#line 11335 "configure"
#line 11376 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
/* We use char because int might match the return type of a gcc2
@ -11342,7 +11383,7 @@ int main() {
socket()
; return 0; }
EOF
if { (eval echo configure:11346: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
if { (eval echo configure:11387: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
@ -11382,16 +11423,16 @@ ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftes
cross_compiling=$ac_cv_prog_cxx_cross
echo $ac_n "checking the type of the third argument of getsockname""... $ac_c" 1>&6
echo "configure:11386: checking the type of the third argument of getsockname" >&5
echo "configure:11427: checking the type of the third argument of getsockname" >&5
cat > conftest.$ac_ext <<EOF
#line 11388 "configure"
#line 11429 "configure"
#include "confdefs.h"
#include <sys/socket.h>
int main() {
socklen_t len; getsockname(0, 0, &len);
; return 0; }
EOF
if { (eval echo configure:11395: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
if { (eval echo configure:11436: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
cat >> confdefs.h <<\EOF
#define SOCKLEN_T socklen_t
@ -11402,14 +11443,14 @@ else
cat conftest.$ac_ext >&5
rm -rf conftest*
cat > conftest.$ac_ext <<EOF
#line 11406 "configure"
#line 11447 "configure"
#include "confdefs.h"
#include <sys/socket.h>
int main() {
size_t len; getsockname(0, 0, &len);
; return 0; }
EOF
if { (eval echo configure:11413: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
if { (eval echo configure:11454: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
cat >> confdefs.h <<\EOF
#define SOCKLEN_T size_t
@ -11420,14 +11461,14 @@ else
cat conftest.$ac_ext >&5
rm -rf conftest*
cat > conftest.$ac_ext <<EOF
#line 11424 "configure"
#line 11465 "configure"
#include "confdefs.h"
#include <sys/socket.h>
int main() {
int len; getsockname(0, 0, &len);
; return 0; }
EOF
if { (eval echo configure:11431: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
if { (eval echo configure:11472: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
cat >> confdefs.h <<\EOF
#define SOCKLEN_T int
@ -11469,17 +11510,17 @@ if test "$wxUSE_JOYSTICK" = 1; then
do
ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
echo "configure:11473: checking for $ac_hdr" >&5
echo "configure:11514: checking for $ac_hdr" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
#line 11478 "configure"
#line 11519 "configure"
#include "confdefs.h"
#include <$ac_hdr>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:11483: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
{ (eval echo configure:11524: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
@ -11521,12 +11562,12 @@ if test "$wxUSE_DYNLIB_CLASS" = "yes"; then
for ac_func in dlopen
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
echo "configure:11525: checking for $ac_func" >&5
echo "configure:11566: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
#line 11530 "configure"
#line 11571 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
@ -11549,7 +11590,7 @@ $ac_func();
; return 0; }
EOF
if { (eval echo configure:11553: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
if { (eval echo configure:11594: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
@ -11577,7 +11618,7 @@ EOF
else
echo "$ac_t""no" 1>&6
echo $ac_n "checking for dlopen in -ldl""... $ac_c" 1>&6
echo "configure:11581: checking for dlopen in -ldl" >&5
echo "configure:11622: checking for dlopen in -ldl" >&5
ac_lib_var=`echo dl'_'dlopen | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
@ -11585,7 +11626,7 @@ else
ac_save_LIBS="$LIBS"
LIBS="-ldl $LIBS"
cat > conftest.$ac_ext <<EOF
#line 11589 "configure"
#line 11630 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
/* We use char because int might match the return type of a gcc2
@ -11596,7 +11637,7 @@ int main() {
dlopen()
; return 0; }
EOF
if { (eval echo configure:11600: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
if { (eval echo configure:11641: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
@ -11625,12 +11666,12 @@ else
for ac_func in shl_load
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
echo "configure:11629: checking for $ac_func" >&5
echo "configure:11670: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
#line 11634 "configure"
#line 11675 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
@ -11653,7 +11694,7 @@ $ac_func();
; return 0; }
EOF
if { (eval echo configure:11657: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
if { (eval echo configure:11698: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
@ -11872,17 +11913,17 @@ if test "$wxUSE_DRAG_AND_DROP" = "yes" ; then
do
ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
echo "configure:11876: checking for $ac_hdr" >&5
echo "configure:11917: checking for $ac_hdr" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
#line 11881 "configure"
#line 11922 "configure"
#include "confdefs.h"
#include <$ac_hdr>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
{ (eval echo configure:11886: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
{ (eval echo configure:11927: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
@ -12350,7 +12391,7 @@ SAMPLES_SUBDIRS="`echo $SAMPLES_SUBDIRS | tr -s ' ' | tr ' ' '\n' | sort | uniq
echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
echo "configure:12354: checking whether ${MAKE-make} sets \${MAKE}" >&5
echo "configure:12395: checking whether ${MAKE-make} sets \${MAKE}" >&5
set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6

25
configure.in
View File

@ -2386,9 +2386,30 @@ dnl time/date functions
dnl ------------------------------------------------------------------------
if test "$wxUSE_TIMEDATE" = "yes"; then
AC_CHECK_FUNCS(gettimeofday localtime ftime)
dnl check for localtime (POSIX), gettimeofday (SVr4, BSD 4.3) and ftime
dnl (V7, BSD 4.3)
AC_CHECK_FUNCS(localtime gettimeofday ftime, break)
if test "$ac_cv_func_gettimeofday" = "yes"; then
if test "$ac_cv_func_localtime" = "yes"; then
AC_CACHE_CHECK(for tm_gmtoff in struct tm,
wx_cv_struct_tm_has_gmtoff,
[
AC_TRY_COMPILE(
[
#include <time.h>
],
[
struct tm tm;
tm.tm_gmtoff++;
],
[
wx_cv_struct_tm_has_gmtoff=yes,
AC_DEFINE(WX_GMTOFF_IN_TM)
],
wx_cv_struct_tm_has_gmtoff=no
)
])
elif test "$ac_cv_func_gettimeofday" = "yes"; then
AC_CACHE_CHECK([whether gettimeofday takes two arguments],
wx_cv_func_gettimeofday_has_2_args,
[

10
docs/changes.txt
View File

@ -4,8 +4,18 @@ wxWindows 2 Change Log
next release (2.1.12 or 2.2?)
-----------------------------
all:
- wxStopWatch class, timer functions have more chances to return correct
results for your platform (use ANSI function where available)
wxMSW:
- arbitrary controls (and not only buttons) can be put into a toolbar
wxGTK:
- wxFontMapper endless recursion bug (on some systems) fixed
- you can use UpdateUI handlers with wxTextCtrl
NOTE: for changes after wxWindows 2.1.0 b4, please see the CVS

21
include/wx/gtk/timer.h
View File

@ -12,41 +12,26 @@
#define __GTKTIMERH__
#ifdef __GNUG__
#pragma interface
#pragma interface "timer.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
//-----------------------------------------------------------------------------
// derived classes
//-----------------------------------------------------------------------------
class wxTimer;
//-----------------------------------------------------------------------------
// wxTimer
//-----------------------------------------------------------------------------
class wxTimer: public wxObject
class wxTimer : public wxTimerBase
{
public:
wxTimer();
~wxTimer();
int Interval() const { return m_time; }
bool OneShot() const { return m_oneShot; }
virtual bool Start( int millisecs = -1, bool oneShot = FALSE );
virtual void Stop();
virtual void Notify() = 0; // override this
virtual bool IsRunning() const { return m_tag != -1; }
protected:
int m_tag;
int m_time;
bool m_oneShot;
private:
DECLARE_ABSTRACT_CLASS(wxTimer)

21
include/wx/gtk1/timer.h
View File

@ -12,41 +12,26 @@
#define __GTKTIMERH__
#ifdef __GNUG__
#pragma interface
#pragma interface "timer.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
//-----------------------------------------------------------------------------
// derived classes
//-----------------------------------------------------------------------------
class wxTimer;
//-----------------------------------------------------------------------------
// wxTimer
//-----------------------------------------------------------------------------
class wxTimer: public wxObject
class wxTimer : public wxTimerBase
{
public:
wxTimer();
~wxTimer();
int Interval() const { return m_time; }
bool OneShot() const { return m_oneShot; }
virtual bool Start( int millisecs = -1, bool oneShot = FALSE );
virtual void Stop();
virtual void Notify() = 0; // override this
virtual bool IsRunning() const { return m_tag != -1; }
protected:
int m_tag;
int m_time;
bool m_oneShot;
private:
DECLARE_ABSTRACT_CLASS(wxTimer)

34
include/wx/motif/timer.h
View File

@ -13,36 +13,28 @@
#define _WX_TIMER_H_
#ifdef __GNUG__
#pragma interface "timer.h"
#pragma interface "timer.h"
#endif
#include "wx/object.h"
class WXDLLEXPORT wxTimer: public wxObject
class WXDLLEXPORT wxTimer : public wxTimerBase
{
DECLARE_DYNAMIC_CLASS(wxTimer)
friend void wxTimerCallback(wxTimer * timer);
friend void wxTimerCallback (wxTimer * timer);
public:
wxTimer();
~wxTimer();
public:
wxTimer();
~wxTimer();
virtual bool Start(int milliseconds = -1,bool one_shot = FALSE); // Start timer
virtual void Stop(); // Stop timer
virtual void Notify() = 0; // Override this member
inline int Interval() { return m_milli ; }; // Returns the current interval time (0 if stop)
virtual bool Start(int milliseconds = -1, bool oneShot = FALSE);
virtual void Stop();
virtual bool IsRunning() const { return m_id != 0; }
protected:
bool m_oneShot ;
int m_milli ;
int m_lastMilli ;
long m_id;
long m_id;
private:
DECLARE_DYNAMIC_CLASS(wxTimer)
};
/* Note: these are implemented in common/timercmn.cpp, so need to implement them separately.
* But you may need to modify timercmn.cpp.
*/
#endif
// _WX_TIMER_H_

23
include/wx/msw/timer.h
View File

@ -13,12 +13,10 @@
#define _WX_TIMER_H_
#ifdef __GNUG__
#pragma interface "timer.h"
#pragma interface "timer.h"
#endif
#include "wx/object.h"
class WXDLLEXPORT wxTimer : public wxObject
class WXDLLEXPORT wxTimer : public wxTimerBase
{
friend void wxProcessTimer(wxTimer& timer);
@ -26,22 +24,13 @@ public:
wxTimer();
~wxTimer();
virtual bool Start(int milliseconds = -1,
bool one_shot = FALSE); // Start timer
virtual void Stop(); // Stop timer
virtual bool Start(int milliseconds = -1, bool oneShot = FALSE);
virtual void Stop();
virtual void Notify() = 0; // Override this member
// Returns the current interval time (0 if stop)
int Interval() const { return milli; };
bool OneShot() const { return oneShot; }
virtual bool IsRunning() const { return m_id != 0; }
protected:
bool oneShot;
int milli;
int lastMilli;
long id;
long m_id;
private:
DECLARE_ABSTRACT_CLASS(wxTimer)

2
include/wx/msw/winundef.h
View File

@ -128,7 +128,7 @@
#ifdef StartDoc
#undef StartDoc
#ifdef __GNUWIN32__
#ifdef __GNUG__
#define DOCINFOW DOCINFO
#define DOCINFOA DOCINFO
#endif

164
include/wx/timer.h
View File

@ -1,45 +1,139 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/timer.h
// Purpose: wxTimer class and global time-related functions
// Author: Julian Smart
// Modified by:
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TIMER_H_BASE_
#define _WX_TIMER_H_BASE_
#if defined(__WXMSW__)
#include "wx/msw/timer.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/timer.h"
#elif defined(__WXGTK__)
#include "wx/gtk/timer.h"
#elif defined(__WXQT__)
#include "wx/qt/timer.h"
#elif defined(__WXMAC__)
#include "wx/mac/timer.h"
#elif defined(__WXPM__)
#include "wx/os2/timer.h"
#elif defined(__WXSTUBS__)
#include "wx/stubs/timer.h"
#ifdef __GNUG__
#pragma interface "timerbase.h"
#endif
class WXDLLEXPORT wxChrono
#include "wx/object.h"
// ----------------------------------------------------------------------------
// wxTimer
// ----------------------------------------------------------------------------
// the interface of wxTimer class
class WXDLLEXPORT wxTimerBase : public wxObject
{
public:
wxChrono();
void Start(long t=0);
void Pause();
void Resume();
public:
wxTimerBase() { m_oneShot = FALSE; m_milli = 0; }
long Time();
// working with the timer
// ----------------------
private:
long m_t0;
long m_pause;
// start the timer: if milliseconds == -1, use the same value as for the
// last Start()
virtual bool Start(int milliseconds = -1, bool oneShot = FALSE)
{
if ( milliseconds != -1 )
{
m_milli = milliseconds;
}
m_oneShot = oneShot;
return TRUE;
}
// stop the timer
virtual void Stop() = 0;
// override this in your wxTimer-derived class
virtual void Notify() = 0;
// getting info
// ------------
// return TRUE if the timer is running
virtual bool IsRunning() const = 0;
// get the (last) timer interval in the milliseconds
int GetInterval() const { return m_milli; }
// return TRUE if the timer is one shot
bool IsOneShot() const { return m_oneShot; }
#if WXWIN_COMPATIBILITY_2
// deprecated functions
int Interval() const { return GetInterval(); };
bool OneShot() const { return IsOneShot(); }
#endif // WXWIN_COMPATIBILITY_2
protected:
int m_milli; // the timer interval
bool m_oneShot; // TRUE if one shot
};
// Timer functions (milliseconds)
#if defined(__WXMSW__)
#include "wx/msw/timer.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/timer.h"
#elif defined(__WXGTK__)
#include "wx/gtk/timer.h"
#elif defined(__WXQT__)
#include "wx/qt/timer.h"
#elif defined(__WXMAC__)
#include "wx/mac/timer.h"
#elif defined(__WXPM__)
#include "wx/os2/timer.h"
#elif defined(__WXSTUBS__)
#include "wx/stubs/timer.h"
#endif
// ----------------------------------------------------------------------------
// wxStopWatch
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxStopWatch
{
public:
// ctor starts the stop watch
wxStopWatch() { Start(); }
void Start(long t = 0); // (re)start it t milliseconds ago
inline void Pause();
void Resume() { Start(m_pause); }
// get the elapsed time since the last Start() or Pause() in milliseconds
long Time() const;
protected:
// returns the elapsed time since t0
inline long GetElapsedTime() const;
private:
long m_t0; // the time of the last Start()
long m_pause; // the time of the last Pause() or 0
};
// the old name
#ifdef WXWIN_COMPATIBILITY_2
typedef wxStopWatch wxChrono;
#endif // WXWIN_COMPATIBILITY_2
// ----------------------------------------------------------------------------
// global time functions
// ----------------------------------------------------------------------------
// Timer functions (milliseconds) -- use wxStopWatch instead
void WXDLLEXPORT wxStartTimer();
// Gets time since last wxStartTimer or wxGetElapsedTime
// Gets time since last wxStartTimer or wxGetElapsedTime -- use wxStopWatch
// instead
long WXDLLEXPORT wxGetElapsedTime(bool resetTimer = TRUE);
// EXPERIMENTAL: comment this out if it doesn't compile.
// Get the local time
bool WXDLLEXPORT wxGetLocalTime(long *timeZone, int *dstObserved);
// Get number of seconds since 00:00:00 GMT, Jan 1st 1970.
@ -48,5 +142,19 @@ long WXDLLEXPORT wxGetCurrentTime();
// Get number of milliseconds since 00:00:00 GMT, Jan 1st 1970.
long WXDLLEXPORT wxGetCurrentMTime();
// ----------------------------------------------------------------------------
// inline functions
// ----------------------------------------------------------------------------
inline long wxStopWatch::GetElapsedTime() const
{
return wxGetCurrentMTime() - m_t0;
}
inline void wxStopWatch::Pause()
{
m_pause = GetElapsedTime();
}
#endif
// _WX_TIMER_H_BASE_

3
setup.h.in
View File

@ -584,6 +584,9 @@
* have only one, in which case define WX_GETTIMEOFDAY_NO_TZ */
#undef WX_GETTIMEOFDAY_NO_TZ
/* struct tm doesn't always have the tm_gmtoff field, define this if it does */
#undef WX_GMTOFF_IN_TM
/* Define if you have dlopen() */
#undef HAVE_DLOPEN

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();