added missing header to fix !USE_PCH compilation

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

diff --git a/include/wx/flags.h b/include/wx/flags.h
index 76378fed3b10c37ebe1b997df1adab659b42e0ea..cd5b2e3dba4d9ee14b0e26826f2f17bb254e8117 100644 (file)
--- a/include/wx/flags.h
+++ b/include/wx/flags.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/flags.h
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/flags.h

-// Purpose:     a bitset suited for replacing the current style flags 
+// Purpose:     a bitset suited for replacing the current style flags

 // Author:      Stefan Csomor
 // Author:      Stefan Csomor

-// Modified by: 
+// Modified by:

 // Created:     27/07/03
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 Stefan Csomor
 // Created:     27/07/03
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 Stefan Csomor

-// Licence:     wxWidgets licence
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_SETH__
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_SETH__


@@ -20,16 +20,16 @@
 // bitwise operators but keeps the type safety and information, the
 // enums must be in a sequence , their value determines the bit position
 // that they represent
 // bitwise operators but keeps the type safety and information, the
 // enums must be in a sequence , their value determines the bit position
 // that they represent

-// The api is made as close as possible to <bitset> 
+// The api is made as close as possible to <bitset>

 
 template <class T> class wxBitset
 {
 
 template <class T> class wxBitset
 {

-       friend class wxEnumData ;
+    friend class wxEnumData ;

 public:
     // creates a wxBitset<> object with all flags initialized to 0
     wxBitset() { m_data = 0; }
 
 public:
     // creates a wxBitset<> object with all flags initialized to 0
     wxBitset() { m_data = 0; }
 

-    // created a wxBitset<> object initialized according to the bits of the 
+    // created a wxBitset<> object initialized according to the bits of the

     // integral value val
     wxBitset(unsigned long val) { m_data = val ; }
 
     // integral value val
     wxBitset(unsigned long val) { m_data = val ; }
 


@@ -45,116 +45,116 @@ public:
     // assignment
     wxBitset &operator =(const wxBitset &rhs)
     {
     // assignment
     wxBitset &operator =(const wxBitset &rhs)
     {

-               m_data = rhs.m_data;
-               return *this;
+        m_data = rhs.m_data;
+        return *this;

     }
 
     // bitwise or operator, sets all bits that are in rhs and leaves
     // the rest unchanged
     }
 
     // bitwise or operator, sets all bits that are in rhs and leaves
     // the rest unchanged

-    wxBitset &operator |=(const wxBitset &rhs) 
+    wxBitset &operator |=(const wxBitset &rhs)

     {
     {

-               m_data |= rhs.m_data;
-               return *this;
+        m_data |= rhs.m_data;
+        return *this;

     }
 
     // bitwsie exclusive-or operator, toggles the value of all bits
     // that are set in bits and leaves all others unchanged
     wxBitset &operator ^=(const wxBitset &rhs) // difference
     {
     }
 
     // bitwsie exclusive-or operator, toggles the value of all bits
     // that are set in bits and leaves all others unchanged
     wxBitset &operator ^=(const wxBitset &rhs) // difference
     {

-               m_data ^= rhs.m_data;
-               return *this;
+        m_data ^= rhs.m_data;
+        return *this;

     }
 
     // bitwise and operator, resets all bits that are not in rhs and leaves
     // all others unchanged
     wxBitset &operator &=(const wxBitset &rhs) // intersection
     {
     }
 
     // bitwise and operator, resets all bits that are not in rhs and leaves
     // all others unchanged
     wxBitset &operator &=(const wxBitset &rhs) // intersection
     {

-               m_data &= rhs.m_data;
-               return *this;
+        m_data &= rhs.m_data;
+        return *this;

     }
 
     }
 

-    // bitwise or operator, returns a new bitset that has all bits set that set are in 
+    // bitwise or operator, returns a new bitset that has all bits set that set are in

     // bitset2 or in this bitset
     // bitset2 or in this bitset

-   wxBitset operator |(const wxBitset &bitset2) const // union
+    wxBitset operator |(const wxBitset &bitset2) const // union

     {
     {

-               wxBitset<T> s;
-               s.m_data = m_data | bitset2.m_data;
-               return s;
+        wxBitset<T> s;
+        s.m_data = m_data | bitset2.m_data;
+        return s;

     }
 
     }
 

-    // bitwise exclusive-or operator, returns a new bitset that has all bits set that are set either in 
+    // bitwise exclusive-or operator, returns a new bitset that has all bits set that are set either in

     // bitset2 or in this bitset but not in both
     wxBitset operator ^(const wxBitset &bitset2) const // difference
     {
     // bitset2 or in this bitset but not in both
     wxBitset operator ^(const wxBitset &bitset2) const // difference
     {

-               wxBitset<T> s;
-               s.m_data = m_data ^ bitset2.m_data;
-               return s;
+        wxBitset<T> s;
+        s.m_data = m_data ^ bitset2.m_data;
+        return s;

     }
 
     }
 

-    // bitwise and operator, returns a new bitset that has all bits set that are set both in 
+    // bitwise and operator, returns a new bitset that has all bits set that are set both in

     // bitset2 and in this bitset
     wxBitset operator &(const wxBitset &bitset2) const // intersection
     {
     // bitset2 and in this bitset
     wxBitset operator &(const wxBitset &bitset2) const // intersection
     {

-               wxBitset<T> s;
-               s.m_data = m_data & bitset2.m_data;
-               return s;
+        wxBitset<T> s;
+        s.m_data = m_data & bitset2.m_data;
+        return s;

     }
 
     // sets appropriate the bit to true
     wxBitset& set(const T el) //Add element
     {
     }
 
     // sets appropriate the bit to true
     wxBitset& set(const T el) //Add element
     {

-               m_data |= 1 << el;
-               return *this;
+        m_data |= 1 << el;
+        return *this;

     }
     }

-    
+

     // clears the appropriate flag to false
     wxBitset& reset(const T el) //remove element
     {
     // clears the appropriate flag to false
     wxBitset& reset(const T el) //remove element
     {

-               m_data &= ~(1 << el);
-               return *this;
+        m_data &= ~(1 << el);
+        return *this;

     }
 
     // clear all flags
     wxBitset& reset()
     {
     }
 
     // clear all flags
     wxBitset& reset()
     {

-               m_data = 0;
-               return *this;
+        m_data = 0;
+        return *this;

     }
 
     // true if this flag is set
     bool test(const T el) const
     {
     }
 
     // true if this flag is set
     bool test(const T el) const
     {

-               return (m_data & (1 << el)) ? true : false;
+        return (m_data & (1 << el)) ? true : false;

     }
 
     // true if no flag is set
     bool none() const
     {
     }
 
     // true if no flag is set
     bool none() const
     {

-               return m_data == 0;
+        return m_data == 0;

     }
 
     // true if any flag is set
     bool any() const
     {
     }
 
     // true if any flag is set
     bool any() const
     {

-               return m_data != 0;
+        return m_data != 0;

     }
 
     // true if both have the same flags
     bool operator ==(const wxBitset &rhs) const
     {
     }
 
     // true if both have the same flags
     bool operator ==(const wxBitset &rhs) const
     {

-               return m_data == rhs.m_data;
+        return m_data == rhs.m_data;

     }
 
     // true if both differ in their flags set
     bool operator !=(const wxBitset &rhs) const
     {
     }
 
     // true if both differ in their flags set
     bool operator !=(const wxBitset &rhs) const
     {

-               return !operator==(rhs);
+        return !operator==(rhs);

     }
 
     bool operator[] (const T el) const { return test(el) ; }
 
 private :
     }
 
     bool operator[] (const T el) const { return test(el) ; }
 
 private :

-       unsigned long m_data;
+    unsigned long m_data;

 };
 
 #define WX_DEFINE_FLAGS( flags ) \
 };
 
 #define WX_DEFINE_FLAGS( flags ) \