wxMDIChildFrame::Maximize() should have default value for its argument just as wxFram...

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

diff --git a/include/wx/longlong.h b/include/wx/longlong.h
index 725ff72c66fc12c1d1d66f0464aa54e06c8889d9..5670a66fab343e250545fa229a55ba15ef407759 100644 (file)
--- a/include/wx/longlong.h
+++ b/include/wx/longlong.h
@@ -13,7 +13,7 @@
 #ifndef _WX_LONGLONG_H
 #define _WX_LONGLONG_H
 
 #ifndef _WX_LONGLONG_H
 #define _WX_LONGLONG_H
 

-#if defined(__GNUG__) && !defined(__APPLE__)
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma interface "longlong.h"
 #endif
 
     #pragma interface "longlong.h"
 #endif
 


@@ -38,69 +38,21 @@
 // decide upon which class we will use
 // ----------------------------------------------------------------------------
 
 // decide upon which class we will use
 // ----------------------------------------------------------------------------
 

-// to avoid compilation problems on 64bit machines with ambiguous method calls
-// we will need to define this
-#undef wxLongLongIsLong
-
-// NB: we #define and not typedef wxLongLong_t because we want to be able to
-//     use 'unsigned wxLongLong_t' as well and because we use "#ifdef
-//     wxLongLong_t" below
-
-// first check for generic cases which are long on 64bit machine and "long
-// long", then check for specific compilers
-#if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
-    #define wxLongLong_t long
-    #define wxLongLongSuffix l
-    #define wxLongLongFmtSpec _T("l")
-    #define wxLongLongIsLong
-#elif (defined(__VISUALC__) && defined(__WIN32__)) || defined( __VMS__ )
-    #define wxLongLong_t __int64
-    #define wxLongLongSuffix i64
-    #define wxLongLongFmtSpec _T("I64")
-#elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
-    #define wxLongLong_t __int64
-    #define wxLongLongSuffix i64
-    #define wxLongLongFmtSpec _T("Ld")
-#elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8)  || \
-        defined(__MINGW32__) || \
-        defined(__GNUC__) || \
-        defined(__CYGWIN__) || \
-        defined(__WXMICROWIN__) || \
-        (defined(__DJGPP__) && __DJGPP__ >= 2)
-    #define wxLongLong_t long long
-    #define wxLongLongSuffix ll
-    #define wxLongLongFmtSpec _T("ll")
-#elif defined(__MWERKS__)
-    #if __option(longlong)
-        #define wxLongLong_t long long
-        #define wxLongLongSuffix ll
-        #define wxLongLongFmtSpec _T("ll")
-    #else
-        #error "The 64 bit integer support in CodeWarrior has been disabled."
-        #error "See the documentation on the 'longlong' pragma."
-    #endif
-#elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
-    #define wxLongLong_t long long
-#else // no native long long type
+#ifndef wxLongLong_t

     // both warning and pragma warning are not portable, but at least an
     // unknown pragma should never be an error -- except that, actually, some
     // broken compilers don't like it, so we have to disable it in this case
     // <sigh>
     // both warning and pragma warning are not portable, but at least an
     // unknown pragma should never be an error -- except that, actually, some
     // broken compilers don't like it, so we have to disable it in this case
     // <sigh>

-#if !(defined(__WATCOMC__) || defined(__VISAGECPP__))
-    #pragma warning "Your compiler does not appear to support 64 bit "\
-                    "integers, using emulation class instead.\n" \
-                    "Please report your compiler version to " \
-                    "wx-dev@lists.wxwindows.org!"
-#endif
+    #if !(defined(__WATCOMC__) || defined(__VISAGECPP__))
+        #pragma warning "Your compiler does not appear to support 64 bit "\
+                        "integers, using emulation class instead.\n" \
+                        "Please report your compiler version to " \
+                        "wx-dev@lists.wxwidgets.org!"
+    #endif

 
     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 
 
     #define wxUSE_LONGLONG_WX 1
 #endif // compiler
 

-// this macro allows to definea 64 bit constant in a portable way
-#define wxMakeLongLong(x, s) x ## s
-#define wxMakeLongLong2(x, s) wxMakeLongLong(x, s)
-#define wxLL(x) wxMakeLongLong2(x, wxLongLongSuffix)
-

 // 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
 // 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


@@ -163,6 +115,9 @@ public:
         m_ll = ((wxLongLong_t) hi) << 32;
         m_ll |= (wxLongLong_t) lo;
     }
         m_ll = ((wxLongLong_t) hi) << 32;
         m_ll |= (wxLongLong_t) lo;
     }

+#if wxUSE_LONGLONG_WX
+    wxLongLongNative(wxLongLongWx ll);
+#endif

 
     // default copy ctor is ok
 
 
     // default copy ctor is ok
 


@@ -172,6 +127,10 @@ public:
         // from native 64 bit integer
     wxLongLongNative& operator=(wxLongLong_t ll)
         { m_ll = ll; return *this; }
         // from native 64 bit integer
     wxLongLongNative& operator=(wxLongLong_t ll)
         { m_ll = ll; return *this; }

+#if wxUSE_LONGLONG_WX
+    wxLongLongNative& operator=(wxLongLongWx ll);
+#endif
+

 
         // from double: this one has an explicit name because otherwise we
         // would have ambiguity with "ll = int" and also because we don't want
 
         // from double: this one has an explicit name because otherwise we
         // would have ambiguity with "ll = int" and also because we don't want


@@ -342,9 +301,13 @@ public:
 
 #if wxUSE_STD_IOSTREAM
         // input/output
 
 #if wxUSE_STD_IOSTREAM
         // input/output

-    friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&);
+    friend WXDLLIMPEXP_BASE
+    wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongNative&);

 #endif
 
 #endif
 

+    friend WXDLLIMPEXP_BASE
+    wxString& operator<<(wxString&, const wxLongLongNative&);
+

 private:
     wxLongLong_t  m_ll;
 };
 private:
     wxLongLong_t  m_ll;
 };


@@ -357,13 +320,13 @@ public:
         // default ctor initializes to 0
     wxULongLongNative() : m_ll(0) { }
         // from long long
         // default ctor initializes to 0
     wxULongLongNative() : m_ll(0) { }
         // from long long

-    wxULongLongNative(unsigned wxLongLong_t ll) : m_ll(ll) { }
+    wxULongLongNative(wxULongLong_t ll) : m_ll(ll) { }

         // from 2 longs
     wxULongLongNative(unsigned long hi, unsigned long lo) : m_ll(0)
     {
         // assign first to avoid precision loss!
         // from 2 longs
     wxULongLongNative(unsigned long hi, unsigned long lo) : m_ll(0)
     {
         // assign first to avoid precision loss!

-        m_ll = ((unsigned wxLongLong_t) hi) << 32;
-        m_ll |= (unsigned wxLongLong_t) lo;
+        m_ll = ((wxULongLong_t) hi) << 32;
+        m_ll |= (wxULongLong_t) lo;

     }
 
     // default copy ctor is ok
     }
 
     // default copy ctor is ok


@@ -372,7 +335,7 @@ public:
 
     // assignment operators
         // from native 64 bit integer
 
     // assignment operators
         // from native 64 bit integer

-    wxULongLongNative& operator=(unsigned wxLongLong_t ll)
+    wxULongLongNative& operator=(wxULongLong_t ll)

         { m_ll = ll; return *this; }
 
     // assignment operators from wxULongLongNative is ok
         { m_ll = ll; return *this; }
 
     // assignment operators from wxULongLongNative is ok


@@ -386,7 +349,7 @@ public:
         { return (unsigned long)m_ll; }
 
         // convert to native ulong long
         { return (unsigned long)m_ll; }
 
         // convert to native ulong long

-    unsigned wxLongLong_t GetValue() const { return m_ll; }
+    wxULongLong_t GetValue() const { return m_ll; }

 
         // convert to ulong with range checking in the debug mode (only!)
     unsigned long ToULong() const
 
         // convert to ulong with range checking in the debug mode (only!)
     unsigned long ToULong() const


@@ -404,9 +367,9 @@ public:
     wxULongLongNative& operator+=(const wxULongLongNative& ll)
         { m_ll += ll.m_ll; return *this; }
 
     wxULongLongNative& operator+=(const wxULongLongNative& ll)
         { m_ll += ll.m_ll; return *this; }
 

-    wxULongLongNative operator+(const unsigned wxLongLong_t ll) const
+    wxULongLongNative operator+(const wxULongLong_t ll) const

         { return wxULongLongNative(m_ll + ll); }
         { return wxULongLongNative(m_ll + ll); }

-    wxULongLongNative& operator+=(const unsigned wxLongLong_t ll)
+    wxULongLongNative& operator+=(const wxULongLong_t ll)

         { m_ll += ll; return *this; }
 
         // pre increment
         { m_ll += ll; return *this; }
 
         // pre increment


@@ -423,9 +386,9 @@ public:
     wxULongLongNative& operator-=(const wxULongLongNative& ll)
         { m_ll -= ll.m_ll; return *this; }
 
     wxULongLongNative& operator-=(const wxULongLongNative& ll)
         { m_ll -= ll.m_ll; return *this; }
 

-    wxULongLongNative operator-(const unsigned wxLongLong_t ll) const
+    wxULongLongNative operator-(const wxULongLong_t ll) const

         { return wxULongLongNative(m_ll - ll); }
         { return wxULongLongNative(m_ll - ll); }

-    wxULongLongNative& operator-=(const unsigned wxLongLong_t ll)
+    wxULongLongNative& operator-=(const wxULongLong_t ll)

         { m_ll -= ll; return *this; }
 
         // pre decrement
         { m_ll -= ll; return *this; }
 
         // pre decrement


@@ -525,11 +488,15 @@ public:
 
 #if wxUSE_STD_IOSTREAM
         // input/output
 
 #if wxUSE_STD_IOSTREAM
         // input/output

-    friend wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongNative&);
+    friend WXDLLIMPEXP_BASE
+    wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongNative&);

 #endif
 
 #endif
 

+    friend WXDLLIMPEXP_BASE
+    wxString& operator<<(wxString&, const wxULongLongNative&);
+

 private:
 private:

-    unsigned wxLongLong_t  m_ll;
+    wxULongLong_t  m_ll;

 };
 
 #endif // wxUSE_LONGLONG_NATIVE
 };
 
 #endif // wxUSE_LONGLONG_NATIVE


@@ -671,6 +638,10 @@ public:
     // comparison
     bool operator==(const wxLongLongWx& ll) const
         { return m_lo == ll.m_lo && m_hi == ll.m_hi; }
     // comparison
     bool operator==(const wxLongLongWx& ll) const
         { return m_lo == ll.m_lo && m_hi == ll.m_hi; }

+#if wxUSE_LONGLONG_NATIVE
+    bool operator==(const wxLongLongNative& ll) const
+        { return m_lo == ll.GetLo() && m_hi == ll.GetHi(); }
+#endif

     bool operator!=(const wxLongLongWx& ll) const
         { return !(*this == ll); }
     bool operator<(const wxLongLongWx& ll) const;
     bool operator!=(const wxLongLongWx& ll) const
         { return !(*this == ll); }
     bool operator<(const wxLongLongWx& ll) const;


@@ -713,9 +684,13 @@ public:
     void *asArray() const;
 
 #if wxUSE_STD_IOSTREAM
     void *asArray() const;
 
 #if wxUSE_STD_IOSTREAM

-    friend wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&);
+    friend WXDLLIMPEXP_BASE
+    wxSTD ostream& operator<<(wxSTD ostream&, const wxLongLongWx&);

 #endif // wxUSE_STD_IOSTREAM
 
 #endif // wxUSE_STD_IOSTREAM
 

+    friend WXDLLIMPEXP_BASE
+    wxString& operator<<(wxString&, const wxLongLongWx&);
+

 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs
 
 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs
 


@@ -765,6 +740,14 @@ public:
 #endif // wxLONGLONG_TEST_MODE
     }
 
 #endif // wxLONGLONG_TEST_MODE
     }
 

+    // from signed to unsigned
+    wxULongLongWx(wxLongLongWx ll)
+    {
+        wxASSERT(ll.GetHi() >= 0);
+        m_hi = (unsigned long)ll.GetHi();
+        m_lo = ll.GetLo();
+    }
+

     // default copy ctor is ok in both cases
 
     // no dtor
     // default copy ctor is ok in both cases
 
     // no dtor


@@ -815,8 +798,8 @@ public:
         // post increment operator
     wxULongLongWx& operator++(int) { return ++(*this); }
 
         // post increment operator
     wxULongLongWx& operator++(int) { return ++(*this); }
 

-        // subraction (FIXME: should return wxLongLong)
-    wxULongLongWx operator-(const wxULongLongWx& ll) const;
+        // substraction
+    wxLongLongWx operator-(const wxULongLongWx& ll) const;

     wxULongLongWx& operator-=(const wxULongLongWx& ll);
 
         // pre decrement operator
     wxULongLongWx& operator-=(const wxULongLongWx& ll);
 
         // pre decrement operator


@@ -887,9 +870,13 @@ public:
     void *asArray() const;
 
 #if wxUSE_STD_IOSTREAM
     void *asArray() const;
 
 #if wxUSE_STD_IOSTREAM

-    friend wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongWx&);
+    friend WXDLLIMPEXP_BASE
+    wxSTD ostream& operator<<(wxSTD ostream&, const wxULongLongWx&);

 #endif // wxUSE_STD_IOSTREAM
 
 #endif // wxUSE_STD_IOSTREAM
 

+    friend WXDLLIMPEXP_BASE
+    wxString& operator<<(wxString&, const wxULongLongWx&);
+

 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs
 
 private:
     // long is at least 32 bits, so represent our 64bit number as 2 longs
 


@@ -902,7 +889,7 @@ private:
         wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
     }
 
         wxASSERT( (m_ll >> 32) == m_hi && (unsigned long)m_ll == m_lo );
     }
 

-    unsigned wxLongLong_t m_ll;
+    wxULongLong_t m_ll;

 #endif // wxLONGLONG_TEST_MODE
 };
 
 #endif // wxLONGLONG_TEST_MODE
 };
 


@@ -934,10 +921,10 @@ inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull !=
 
 inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }
 
 
 inline wxULongLong operator+(unsigned long l, const wxULongLong& ull) { return ull + l; }
 

-// FIXME: this should return wxLongLong
-inline wxULongLong operator-(unsigned long l, const wxULongLong& ull)
+inline wxLongLong operator-(unsigned long l, const wxULongLong& ull)

 {
 {

-    return wxULongLong(l) - ull;
+    wxULongLong ret = wxULongLong(l) - ull;
+    return wxLongLong((long)ret.GetHi(),ret.GetLo());

 }
 
 #endif // _WX_LONGLONG_H
 }
 
 #endif // _WX_LONGLONG_H