新增qwt源码版本

qwtdemo/qwt/qwt_system_clock.cpp

@@ -0,0 +1,396 @@
+/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
+ * Qwt Widget Library
+ * Copyright (C) 1997   Josef Wilgen
+ * Copyright (C) 2002   Uwe Rathmann
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the Qwt License, Version 1.0
+ *****************************************************************************/
+
+#include "qwt_system_clock.h"
+
+#if QT_VERSION >= 0x040800
+#define USE_ELAPSED_TIMER 1
+#endif
+
+#if USE_ELAPSED_TIMER
+
+#include <qelapsedtimer.h>
+
+class QwtSystemClock::PrivateData
+{
+public:
+    QElapsedTimer timer;
+};
+
+QwtSystemClock::QwtSystemClock()
+{
+    d_data = new PrivateData();
+}
+
+QwtSystemClock::~QwtSystemClock()
+{
+    delete d_data;
+}
+    
+bool QwtSystemClock::isNull() const
+{
+    return d_data->timer.isValid();
+}
+        
+void QwtSystemClock::start()
+{
+    d_data->timer.start();
+}
+
+double QwtSystemClock::restart()
+{
+    const qint64 nsecs = d_data->timer.restart();
+    return nsecs / 1e6;
+}
+
+double QwtSystemClock::elapsed() const
+{
+    const qint64 nsecs = d_data->timer.nsecsElapsed();
+    return nsecs / 1e6;
+}
+    
+#else // !USE_ELAPSED_TIMER
+
+#include <qdatetime.h>
+
+#if !defined(Q_OS_WIN)
+#include <unistd.h>
+#endif
+
+#if defined(Q_OS_MAC)
+#include <stdint.h>
+#include <mach/mach_time.h>
+#define QWT_HIGH_RESOLUTION_CLOCK
+#elif defined(_POSIX_TIMERS)
+#include <time.h>
+#define QWT_HIGH_RESOLUTION_CLOCK
+#elif defined(Q_OS_WIN)
+#define QWT_HIGH_RESOLUTION_CLOCK
+#include <qt_windows.h>
+#endif
+
+#if defined(QWT_HIGH_RESOLUTION_CLOCK)
+
+class QwtHighResolutionClock
+{
+public:
+    QwtHighResolutionClock();
+
+    void start();
+    double restart();
+    double elapsed() const;
+
+    bool isNull() const;
+
+    static double precision();
+
+private:
+
+#if defined(Q_OS_MAC)
+    static double msecsTo( uint64_t, uint64_t );
+
+    uint64_t d_timeStamp;
+#elif defined(_POSIX_TIMERS)
+
+    static double msecsTo( const struct timespec &,
+        const struct timespec & );
+
+    static bool isMonotonic();
+
+    struct timespec d_timeStamp;
+    clockid_t d_clockId;
+
+#elif defined(Q_OS_WIN)
+
+    LARGE_INTEGER d_startTicks;
+    LARGE_INTEGER d_ticksPerSecond;
+#endif
+};
+
+#if defined(Q_OS_MAC)
+QwtHighResolutionClock::QwtHighResolutionClock():
+    d_timeStamp( 0 )
+{
+}
+
+double QwtHighResolutionClock::precision()
+{
+    return 1e-6;
+}
+
+void QwtHighResolutionClock::start()
+{
+    d_timeStamp = mach_absolute_time();
+}
+
+double QwtHighResolutionClock::restart()
+{
+    const uint64_t timeStamp = mach_absolute_time();
+    const double elapsed = msecsTo( d_timeStamp, timeStamp );
+    d_timeStamp = timeStamp;
+
+    return elapsed;
+}
+
+double QwtHighResolutionClock::elapsed() const
+{
+    return msecsTo( d_timeStamp, mach_absolute_time() );
+}
+
+bool QwtHighResolutionClock::isNull() const
+{
+    return d_timeStamp == 0;
+}
+
+double QwtHighResolutionClock::msecsTo(
+    uint64_t from, uint64_t to )
+{
+    const uint64_t difference = to - from;
+
+    static double conversion = 0.0;
+    if ( conversion == 0.0 )
+    {
+        mach_timebase_info_data_t info;
+        kern_return_t err = mach_timebase_info( &info );
+
+        // convert the timebase into ms
+        if ( err == 0  )
+            conversion = 1e-6 * ( double ) info.numer / ( double ) info.denom;
+    }
+
+    return conversion * ( double ) difference;
+}
+
+#elif defined(_POSIX_TIMERS)
+
+QwtHighResolutionClock::QwtHighResolutionClock()
+{
+    d_clockId = isMonotonic() ? CLOCK_MONOTONIC : CLOCK_REALTIME;
+    d_timeStamp.tv_sec = d_timeStamp.tv_nsec = 0;
+}
+
+double QwtHighResolutionClock::precision()
+{
+    struct timespec resolution;
+
+    int clockId = isMonotonic() ? CLOCK_MONOTONIC : CLOCK_REALTIME;
+    ::clock_getres( clockId, &resolution );
+
+    return resolution.tv_nsec / 1e3;
+}
+
+inline bool QwtHighResolutionClock::isNull() const
+{
+    return d_timeStamp.tv_sec <= 0 && d_timeStamp.tv_nsec <= 0;
+}
+
+inline void QwtHighResolutionClock::start()
+{
+    ::clock_gettime( d_clockId, &d_timeStamp );
+}
+
+double QwtHighResolutionClock::restart()
+{
+    struct timespec timeStamp;
+    ::clock_gettime( d_clockId, &timeStamp );
+
+    const double elapsed = msecsTo( d_timeStamp, timeStamp );
+
+    d_timeStamp = timeStamp;
+    return elapsed;
+}
+
+inline double QwtHighResolutionClock::elapsed() const
+{
+    struct timespec timeStamp;
+    ::clock_gettime( d_clockId, &timeStamp );
+
+    return msecsTo( d_timeStamp, timeStamp );
+}
+
+inline double QwtHighResolutionClock::msecsTo(
+    const struct timespec &t1, const struct timespec &t2 )
+{
+    return ( t2.tv_sec - t1.tv_sec ) * 1e3
+        + ( t2.tv_nsec - t1.tv_nsec ) * 1e-6;
+}
+
+bool QwtHighResolutionClock::isMonotonic()
+{
+    // code copied from qcore_unix.cpp
+
+#if (_POSIX_MONOTONIC_CLOCK-0 > 0)
+    return true;
+#else
+    static int returnValue = 0;
+
+    if ( returnValue == 0 )
+    {
+#if (_POSIX_MONOTONIC_CLOCK-0 < 0) || !defined(_SC_MONOTONIC_CLOCK)
+        returnValue = -1;
+#elif (_POSIX_MONOTONIC_CLOCK == 0)
+        // detect if the system support monotonic timers
+        const long x = sysconf( _SC_MONOTONIC_CLOCK );
+        returnValue = ( x >= 200112L ) ? 1 : -1;
+#endif
+    }
+
+    return returnValue != -1;
+#endif
+}
+
+#elif defined(Q_OS_WIN)
+
+QwtHighResolutionClock::QwtHighResolutionClock()
+{
+    d_startTicks.QuadPart = 0;
+    QueryPerformanceFrequency( &d_ticksPerSecond );
+}
+
+double QwtHighResolutionClock::precision()
+{
+    LARGE_INTEGER ticks;
+    if ( QueryPerformanceFrequency( &ticks ) && ticks.QuadPart > 0 )
+        return 1e3 / ticks.QuadPart;
+
+    return 0.0;
+}
+
+inline bool QwtHighResolutionClock::isNull() const
+{
+    return d_startTicks.QuadPart <= 0;
+}
+
+inline void QwtHighResolutionClock::start()
+{
+    QueryPerformanceCounter( &d_startTicks );
+}
+
+inline double QwtHighResolutionClock::restart()
+{
+    LARGE_INTEGER ticks;
+    QueryPerformanceCounter( &ticks );
+
+    const double dt = ticks.QuadPart - d_startTicks.QuadPart;
+    d_startTicks = ticks;
+
+    return dt / d_ticksPerSecond.QuadPart * 1e3;
+}
+
+inline double QwtHighResolutionClock::elapsed() const
+{
+    LARGE_INTEGER ticks;
+    QueryPerformanceCounter( &ticks );
+
+    const double dt = ticks.QuadPart - d_startTicks.QuadPart;
+    return dt / d_ticksPerSecond.QuadPart * 1e3;
+}
+
+#endif
+
+#endif // QWT_HIGH_RESOLUTION_CLOCK
+
+class QwtSystemClock::PrivateData
+{
+public:
+#if defined(QWT_HIGH_RESOLUTION_CLOCK)
+    QwtHighResolutionClock *clock;
+#endif
+    QTime time;
+};
+
+//!  Constructs a null clock object.
+QwtSystemClock::QwtSystemClock()
+{
+    d_data = new PrivateData;
+
+#if defined(QWT_HIGH_RESOLUTION_CLOCK)
+    d_data->clock = NULL;
+    if ( QwtHighResolutionClock::precision() > 0.0 )
+        d_data->clock = new QwtHighResolutionClock;
+#endif
+}
+
+//! Destructor
+QwtSystemClock::~QwtSystemClock()
+{
+#if defined(QWT_HIGH_RESOLUTION_CLOCK)
+    delete d_data->clock;
+#endif
+    delete d_data;
+}
+
+/*!
+  \return true if the clock has never been started.
+*/
+bool QwtSystemClock::isNull() const
+{
+#if defined(QWT_HIGH_RESOLUTION_CLOCK)
+    if ( d_data->clock )
+        return d_data->clock->isNull();
+#endif
+
+    return d_data->time.isNull();
+}
+
+/*!
+  Sets the start time to the current time.
+*/
+void QwtSystemClock::start()
+{
+#if defined(QWT_HIGH_RESOLUTION_CLOCK)
+    if ( d_data->clock )
+    {
+        d_data->clock->start();
+        return;
+    }
+#endif
+
+    d_data->time.start();
+}
+
+/*!
+  Set the start time to the current time 
+  \return Time, that is elapsed since the previous start time.
+*/
+double QwtSystemClock::restart()
+{
+#if defined(QWT_HIGH_RESOLUTION_CLOCK)
+    if ( d_data->clock )
+        return d_data->clock->restart();
+#endif
+
+    return d_data->time.restart();
+}
+
+/*!
+  \return Number of milliseconds that have elapsed since the last time
+          start() or restart() was called or 0.0 for null clocks.
+*/
+double QwtSystemClock::elapsed() const
+{
+    double elapsed = 0.0;
+
+#if defined(QWT_HIGH_RESOLUTION_CLOCK)
+    if ( d_data->clock )
+    {
+        if ( !d_data->clock->isNull() )
+            elapsed = d_data->clock->elapsed();
+
+        return elapsed;
+    }
+#endif
+
+    if ( !d_data->time.isNull() )
+        elapsed = d_data->time.elapsed();
+
+    return elapsed;
+}
+
+#endif