GUI thread update and event corrections.

[wxWidgets.git] / include / wx / longlong.h

diff --git a/include/wx/longlong.h b/include/wx/longlong.h
index c39828d061eda3768f3c7657fbe3b9b9a14f0cf2..26be8638bb6551b1c16dd650a1485b187c65f053 100644 (file)
--- a/include/wx/longlong.h
+++ b/include/wx/longlong.h
@@ -25,6 +25,8 @@
 
 #include <limits.h>     // for LONG_MAX
 
+// #define wxUSE_LONGLONG_WX 1 // for testing (VZ)
+
 // ----------------------------------------------------------------------------
 // decide upon which class we will use
 // ----------------------------------------------------------------------------
@@ -39,7 +41,9 @@
 #if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
     #define wxLongLong_t long
     #define wxLongLongIsLong
-#elif defined(__VISUALC__)
+#elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
+    #define wxLongLong_t __int64
+#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x530)
     #define wxLongLong_t __int64
 #elif defined(__GNUG__)
     #define wxLongLong_t long long
@@ -50,19 +54,22 @@
         #error "The 64 bit integer support in CodeWarrior has been disabled."
         #error "See the documentation on the 'longlong' pragma."
     #endif
-#else
-    #if !defined(__VISAGECPP__)
-    // Visualage does not support this pragma
-    #warning "Your compiler does not appear to support 64 bit integers, "\
-             "using emulation class instead."
-    #endif
+#else // no native long long type
+    // both warning and pragma warning are not portable, but at least an
+    // unknown pragma should never be an error.
+    // Err, actually, Watcom C++ doesn't like it.
+#ifndef __WATCOMC__
+    #pragma warning "Your compiler does not appear to support 64 bit "\
+                    "integers, using emulation class instead."
+#endif
+
     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 
 // the user may predefine wxUSE_LONGLONG_NATIVE and/or wxUSE_LONGLONG_NATIVE
 // to disable automatic testing (useful for the test program which defines
 // both classes) but by default we only use one class
-#ifndef wxLongLong_t
+#if (defined(wxUSE_LONGLONG_WX) && wxUSE_LONGLONG_WX) || !defined(wxLongLong_t)
     #undef wxUSE_LONGLONG_NATIVE
     #define wxUSE_LONGLONG_NATIVE 0
     class WXDLLEXPORT wxLongLongWx;
@@ -117,6 +124,12 @@ public:
     wxLongLongNative& operator=(wxLongLong_t ll)
         { m_ll = ll; return *this; }
 
+        // from double: this one has an explicit name because otherwise we
+        // would have ambiguity with "ll = int" and also because we don't want
+        // to have implicit conversions between doubles and wxLongLongs
+    wxLongLongNative& Assign(double d)
+        { m_ll = (wxLongLong_t)d; return *this; }
+
     // assignment operators from wxLongLongNative is ok
 
     // accessors
@@ -128,6 +141,7 @@ public:
         { return (unsigned long)m_ll; }
 
         // get absolute value
+    wxLongLongNative Abs() const { return wxLongLongNative(*this).Abs(); }
     wxLongLongNative& Abs() { if ( m_ll < 0 ) m_ll = -m_ll; return *this; }
 
         // convert to native long long
@@ -306,6 +320,8 @@ public:
         // from long
     wxLongLongWx& operator=(long l)
         { m_lo = l; m_hi = (l < 0 ? -1l : 0l); return *this; }
+        // from double
+    wxLongLongWx& Assign(double d);
         // can't have assignment operator from 2 longs
 
     // accessors
@@ -314,6 +330,19 @@ public:
         // get low part
     unsigned long GetLo() const { return m_lo; }
 
+        // get absolute value
+    wxLongLongWx Abs() const { return wxLongLongWx(*this).Abs(); }
+    wxLongLongWx& Abs() { if ( m_hi < 0 ) m_hi = -m_hi; return *this; }
+
+        // convert to long with range checking in the debug mode (only!)
+    long ToLong() const
+    {
+        wxASSERT_MSG( m_hi == 0l,
+                      _T("wxLongLong to long conversion loss of precision") );
+
+        return (long)m_lo;
+    }
+
     // operations
         // addition
     wxLongLongWx operator+(const wxLongLongWx& ll) const;
@@ -359,28 +388,38 @@ public:
     wxLongLongWx operator~() const;
 
     // comparison
-    bool operator==(const wxLongLongWx& ll) const;
-    bool operator!=(const wxLongLongWx& ll) const;
+    bool operator==(const wxLongLongWx& ll) const
+        { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
+    bool operator!=(const wxLongLongWx& ll) const
+        { return !(*this == ll); }
     bool operator<(const wxLongLongWx& ll) const;
     bool operator>(const wxLongLongWx& ll) const;
-    bool operator<=(const wxLongLongWx& ll) const;
-    bool operator>=(const wxLongLongWx& ll) const;
+    bool operator<=(const wxLongLongWx& ll) const
+        { return *this < ll || *this == ll; }
+    bool operator>=(const wxLongLongWx& ll) const
+        { return *this > ll || *this == ll; }
 
     // multiplication
     wxLongLongWx operator*(const wxLongLongWx& ll) const;
     wxLongLongWx& operator*=(const wxLongLongWx& ll);
-    void *asArray(void) const;
 
     // division
+    wxLongLongWx operator/(const wxLongLongWx& ll) const;
+    wxLongLongWx& operator/=(const wxLongLongWx& ll);
+
+    wxLongLongWx operator%(const wxLongLongWx& ll) const;
+
     void Divide(const wxLongLongWx& divisor,
                 wxLongLongWx& quotient,
                 wxLongLongWx& remainder) const;
 
-#if wxUSE_STD_IOSTREAM
     // input/output
+#if wxUSE_STD_IOSTREAM
     friend ostream& operator<<(ostream&, const wxLongLongWx&);
 #endif // wxUSE_STD_IOSTREAM
 
+    void *asArray(void) const;
+
 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs
 
@@ -390,4 +429,18 @@ private:
 
 #endif // wxUSE_LONGLONG_WX
 
+// ----------------------------------------------------------------------------
+// binary operators
+// ----------------------------------------------------------------------------
+
+inline bool WXDLLEXPORT operator<(long l, const wxLongLong& ll) { return ll > l; }
+inline bool WXDLLEXPORT operator>(long l, const wxLongLong& ll) { return ll > l; }
+inline bool WXDLLEXPORT operator<=(long l, const wxLongLong& ll) { return ll > l; }
+inline bool WXDLLEXPORT operator>=(long l, const wxLongLong& ll) { return ll > l; }
+inline bool WXDLLEXPORT operator==(long l, const wxLongLong& ll) { return ll > l; }
+inline bool WXDLLEXPORT operator!=(long l, const wxLongLong& ll) { return ll > l; }
+
+inline wxLongLong WXDLLEXPORT operator+(long l, const wxLongLong& ll) { return ll + l; }
+inline wxLongLong WXDLLEXPORT operator-(long l, const wxLongLong& ll) { return ll - l; }
+
 #endif // _WX_LONGLONG_H