added (and documented) trivial but useful IsSingleLine() and IsMultiLine() text contr...

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

diff --git a/include/wx/longlong.h b/include/wx/longlong.h
index b0789390d6778ad3e46d6635a75359692c2a7299..80272649a48c658aba497f2e861423b8797eac59 100644 (file)
--- a/include/wx/longlong.h
+++ b/include/wx/longlong.h
@@ -68,6 +68,8 @@
     #endif
 #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
         #define wxLongLong_t long long
     #endif
 #elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
         #define wxLongLong_t long long

+#elif defined(__DJGPP__) && __DJGPP__ >= 2
+    #define wxLongLong_t long long

 #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 - except that, actually, some
 #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 - except that, actually, some


@@ -94,6 +96,7 @@
     #endif
 
     class WXDLLEXPORT wxLongLongWx;
     #endif
 
     class WXDLLEXPORT wxLongLongWx;

+    class WXDLLEXPORT wxULongLongWx;

 #if defined(__VISUALC__) && !defined(__WIN32__)
     #define wxLongLong wxLongLongWx
     #define wxULongLong wxULongLongWx
 #if defined(__VISUALC__) && !defined(__WIN32__)
     #define wxLongLong wxLongLongWx
     #define wxULongLong wxULongLongWx


@@ -134,11 +137,11 @@ class WXDLLEXPORT wxLongLongNative
 public:
     // ctors
         // default ctor initializes to 0
 public:
     // ctors
         // default ctor initializes to 0

-    wxLongLongNative() { m_ll = 0; }
+    wxLongLongNative() : m_ll(0) { }

         // from long long
         // from long long

-    wxLongLongNative(wxLongLong_t ll) { m_ll = ll; }
+    wxLongLongNative(wxLongLong_t ll) : m_ll(ll) { }

         // from 2 longs
         // from 2 longs

-    wxLongLongNative(long hi, unsigned long lo)
+    wxLongLongNative(long hi, unsigned long lo) : m_ll(0)

     {
         // assign first to avoid precision loss!
         m_ll = ((wxLongLong_t) hi) << 32;
     {
         // assign first to avoid precision loss!
         m_ll = ((wxLongLong_t) hi) << 32;


@@ -177,11 +180,6 @@ public:
         // convert to native long long
     wxLongLong_t GetValue() const { return m_ll; }
 
         // convert to native long long
     wxLongLong_t GetValue() const { return m_ll; }
 

-        // implicit conversion for times when we want a native type
-        // or wxLongLong, NOT wxLongLongNative and without having
-        // to ifdef user code for each use.
-    operator wxLongLong_t() const { return m_ll; }
-

         // convert to long with range checking in the debug mode (only!)
     long ToLong() const
     {
         // convert to long with range checking in the debug mode (only!)
     long ToLong() const
     {


@@ -212,8 +210,8 @@ public:
         { m_ll++; return *this; }
 
         // post increment
         { m_ll++; return *this; }
 
         // post increment

-    wxLongLongNative& operator++(int)
-        { m_ll++; return *this; }
+    wxLongLongNative operator++(int)
+        { wxLongLongNative value(*this); m_ll++; return value; }

 
         // negation operator
     wxLongLongNative operator-() const
 
         // negation operator
     wxLongLongNative operator-() const


@@ -236,8 +234,8 @@ public:
         { m_ll--; return *this; }
 
         // post decrement
         { m_ll--; return *this; }
 
         // post decrement

-    wxLongLongNative& operator--(int)
-        { m_ll--; return *this; }
+    wxLongLongNative operator--(int)
+        { wxLongLongNative value(*this); m_ll--; return value; }

 
     // shifts
         // left shift
 
     // shifts
         // left shift


@@ -341,11 +339,11 @@ class WXDLLEXPORT wxULongLongNative
 public:
     // ctors
         // default ctor initializes to 0
 public:
     // ctors
         // default ctor initializes to 0

-    wxULongLongNative() { m_ll = 0; }
+    wxULongLongNative() : m_ll(0) { }

         // from long long
         // from long long

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

         // from 2 longs
         // from 2 longs

-    wxULongLongNative(unsigned long hi, unsigned long lo)
+    wxULongLongNative(unsigned long hi, unsigned long lo) : m_ll(0)

     {
         // assign first to avoid precision loss!
         m_ll = ((unsigned wxLongLong_t) hi) << 32;
     {
         // assign first to avoid precision loss!
         m_ll = ((unsigned wxLongLong_t) hi) << 32;


@@ -383,10 +381,6 @@ public:
         return (unsigned long)m_ll;
     }
 
         return (unsigned long)m_ll;
     }
 

-    // don't provide implicit conversion to unsigned wxLongLong_t or we
-    // will have an ambiguity for all arithmetic operations
-    //operator wxULongLong_t() const { return m_ll; }
-

     // operations
         // addition
     wxULongLongNative operator+(const wxULongLongNative& ll) const
     // operations
         // addition
     wxULongLongNative operator+(const wxULongLongNative& ll) const


@@ -404,8 +398,8 @@ public:
         { m_ll++; return *this; }
 
         // post increment
         { m_ll++; return *this; }
 
         // post increment

-    wxULongLongNative& operator++(int)
-        { m_ll++; return *this; }
+    wxULongLongNative operator++(int)
+        { wxULongLongNative value(*this); m_ll++; return value; }

 
         // subtraction
     wxULongLongNative operator-(const wxULongLongNative& ll) const
 
         // subtraction
     wxULongLongNative operator-(const wxULongLongNative& ll) const


@@ -423,8 +417,8 @@ public:
         { m_ll--; return *this; }
 
         // post decrement
         { m_ll--; return *this; }
 
         // post decrement

-    wxULongLongNative& operator--(int)
-        { m_ll--; return *this; }
+    wxULongLongNative operator--(int)
+        { wxULongLongNative value(*this); m_ll--; return value; }

 
     // shifts
         // left shift
 
     // shifts
         // left shift


@@ -786,7 +780,7 @@ public:
         // convert to long with range checking in the debug mode (only!)
     unsigned long ToULong() const
     {
         // convert to long with range checking in the debug mode (only!)
     unsigned long ToULong() const
     {

-        wxASSERT_MSG( (m_hi == 0l),
+        wxASSERT_MSG( m_hi == 0ul,

                       _T("wxULongLong to long conversion loss of precision") );
 
         return (unsigned long)m_lo;
                       _T("wxULongLong to long conversion loss of precision") );
 
         return (unsigned long)m_lo;


@@ -805,7 +799,7 @@ public:
         // post increment operator
     wxULongLongWx& operator++(int) { return ++(*this); }
 
         // post increment operator
     wxULongLongWx& operator++(int) { return ++(*this); }
 

-        // subraction
+        // subraction (FIXME: should return wxLongLong)

     wxULongLongWx operator-(const wxULongLongWx& ll) const;
     wxULongLongWx& operator-=(const wxULongLongWx& ll);
 
     wxULongLongWx operator-(const wxULongLongWx& ll) const;
     wxULongLongWx& operator-=(const wxULongLongWx& ll);
 


@@ -883,7 +877,7 @@ public:
 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
 

-    unsigned long m_hi
+    unsigned long m_hi;

     unsigned long m_lo;
 
 #ifdef wxLONGLONG_TEST_MODE
     unsigned long m_lo;
 
 #ifdef wxLONGLONG_TEST_MODE


@@ -903,30 +897,31 @@ private:
 // ----------------------------------------------------------------------------
 
 inline bool operator<(long l, const wxLongLong& ll) { return ll > l; }
 // ----------------------------------------------------------------------------
 
 inline bool operator<(long l, const wxLongLong& ll) { return ll > l; }

-inline bool operator>(long l, const wxLongLong& ll) { return ll > l; }
-inline bool operator<=(long l, const wxLongLong& ll) { return ll > l; }
-inline bool operator>=(long l, const wxLongLong& ll) { return ll > l; }
-inline bool operator==(long l, const wxLongLong& ll) { return ll > l; }
-inline bool operator!=(long l, const wxLongLong& ll) { return ll > l; }
-
-inline wxLongLong operator+(long l, const wxLongLong& ll)
-{
-    return ll + wxLongLong(l);
-}
+inline bool operator>(long l, const wxLongLong& ll) { return ll < l; }
+inline bool operator<=(long l, const wxLongLong& ll) { return ll >= l; }
+inline bool operator>=(long l, const wxLongLong& ll) { return ll <= l; }
+inline bool operator==(long l, const wxLongLong& ll) { return ll == l; }
+inline bool operator!=(long l, const wxLongLong& ll) { return ll != l; }

 
 

+inline wxLongLong operator+(long l, const wxLongLong& ll) { return ll + l; }

 inline wxLongLong operator-(long l, const wxLongLong& ll)
 {
 inline wxLongLong operator-(long l, const wxLongLong& ll)
 {

-    return ll - wxLongLong(l);
+    return wxLongLong(l) - ll;

 }
 
 }
 

-inline bool operator<(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator>(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator<=(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator>=(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator==(unsigned long l, const wxULongLong& ll) { return ll > l; }
-inline bool operator!=(unsigned long l, const wxULongLong& ll) { return ll > l; }
+inline bool operator<(unsigned long l, const wxULongLong& ull) { return ull > l; }
+inline bool operator>(unsigned long l, const wxULongLong& ull) { return ull < l; }
+inline bool operator<=(unsigned long l, const wxULongLong& ull) { return ull >= l; }
+inline bool operator>=(unsigned long l, const wxULongLong& ull) { return ull <= l; }
+inline bool operator==(unsigned long l, const wxULongLong& ull) { return ull == l; }
+inline bool operator!=(unsigned long l, const wxULongLong& ull) { return ull != l; }

 
 

-inline wxULongLong operator+(unsigned long l, const wxULongLong& ll) { return ll + l; }
-inline wxULongLong operator-(unsigned long l, const wxULongLong& ll) { return ll - 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)
+{
+    return wxULongLong(l) - ull;
+}

 
 #endif // _WX_LONGLONG_H
 
 #endif // _WX_LONGLONG_H