Add wx/datetimectrl.h to the wxAdv files list.

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

diff --git a/include/wx/weakref.h b/include/wx/weakref.h
index 9ae506798be80648194f467ebcd404f8a3305037..a17c36d91b2ca6e581ca132c808aea0ce3222fd8 100644 (file)
--- a/include/wx/weakref.h
+++ b/include/wx/weakref.h
@@ -13,6 +13,23 @@
 
 #include "wx/tracker.h"
 
 
 #include "wx/tracker.h"
 

+
+// Some compilers (VC6, Borland, g++ < 3.3) have problem with template specialization.
+// However, this is only used for optimization purposes (a smaller wxWeakRef pointer)
+// (and the corner case of wxWeakRef<wxObject>). So for those compilers, we can fall
+// back to the non-optimal case, where we use the same type of weak ref (static one)
+// in all cases. See defs.h for various setting these defines depending on compiler.
+
+#if !defined(HAVE_PARTIAL_SPECIALIZATION) || \
+    !defined(HAVE_TEMPLATE_OVERLOAD_RESOLUTION) || \
+    (defined(__GNUC__) && !wxCHECK_GCC_VERSION(3, 3))
+    #define USE_ONLY_STATIC_WEAKREF
+#endif
+
+
+#ifndef USE_ONLY_STATIC_WEAKREF
+
+// Avoid including this for simpler compilers

 #include "wx/meta/convertible.h"
 #include "wx/meta/int2type.h"
 
 #include "wx/meta/convertible.h"
 #include "wx/meta/int2type.h"
 


@@ -22,6 +39,9 @@ struct wxIsStaticTrackable
     enum { value = wxConvertibleTo<T, wxTrackable>::value };
 };
 
     enum { value = wxConvertibleTo<T, wxTrackable>::value };
 };
 

+#endif // !USE_ONLY_STATIC_WEAKREF
+
+

 // Weak ref implementation when T has wxTrackable as a known base class
 template <class T>
 class wxWeakRefStatic : public wxTrackerNode
 // Weak ref implementation when T has wxTrackable as a known base class
 template <class T>
 class wxWeakRefStatic : public wxTrackerNode


@@ -41,6 +61,13 @@ public:
         }
     }
 
         }
     }
 

+    virtual void OnObjectDestroy()
+    {
+        // Tracked object itself removes us from list of trackers
+        wxASSERT(m_pobj != NULL);
+        m_pobj = NULL;
+    }
+

 protected:
     void Assign(T* pobj)
     {
 protected:
     void Assign(T* pobj)
     {


@@ -64,17 +91,12 @@ protected:
         Assign( wr.m_pobj );
     }
 
         Assign( wr.m_pobj );
     }
 

-    virtual void OnObjectDestroy()
-    {
-        // Tracked object itself removes us from list of trackers
-        wxASSERT( m_pobj!=NULL );
-        m_pobj = NULL;
-    }
-

     T *m_pobj;
 };
 
     T *m_pobj;
 };
 

-#ifdef HAVE_PARTIAL_SPECIALIZATION
+
+
+#ifndef USE_ONLY_STATIC_WEAKREF

 
 template<class T,bool use_static>
 struct wxWeakRefImpl;
 
 template<class T,bool use_static>
 struct wxWeakRefImpl;


@@ -102,6 +124,14 @@ struct wxWeakRefImpl<T, false> : public wxTrackerNode
         }
     }
 
         }
     }
 

+    virtual void OnObjectDestroy()
+    {
+        // Tracked object itself removes us from list of trackers
+        wxASSERT(m_pobj != NULL);
+        m_pobj = NULL;
+        m_ptbase = NULL;
+    }
+

 protected:
     wxWeakRefImpl() : m_pobj(NULL), m_ptbase(NULL) { }
 
 protected:
     wxWeakRefImpl() : m_pobj(NULL), m_ptbase(NULL) { }
 


@@ -119,7 +149,7 @@ protected:
         DoAssign( pobj, ptbase );
     }
 
         DoAssign( pobj, ptbase );
     }
 

-#ifdef HAVE_DYNAMIC_CAST
+#ifndef wxNO_RTTI

     void AssignHelper(T* pobj, wxInt2Type<false>)
     {
         // A last way to get a trackable pointer
     void AssignHelper(T* pobj, wxInt2Type<false>)
     {
         // A last way to get a trackable pointer


@@ -135,7 +165,7 @@ protected:
             Release();
         }
     }
             Release();
         }
     }

-#endif // HAVE_DYNAMIC_CAST
+#endif // RTTI enabled

 
     void AssignCopy(const wxWeakRefImpl& wr)
     {
 
     void AssignCopy(const wxWeakRefImpl& wr)
     {


@@ -157,35 +187,41 @@ protected:
         }
     }
 
         }
     }
 

-    virtual void OnObjectDestroy()
-    {
-        // Tracked object itself removes us from list of trackers
-        wxASSERT( m_pobj!=NULL );
-        m_pobj = NULL;
-        m_ptbase = NULL;
-    }
-

     T *m_pobj;
     wxTrackable *m_ptbase;
 };
 
     T *m_pobj;
     wxTrackable *m_ptbase;
 };
 

-#endif // HAVE_PARTIAL_SPECIALIZATION
+#endif // #ifndef USE_ONLY_STATIC_WEAKREF
+

 
 
 
 

-// A weak reference to an object of type T, where T has type wxTrackable
+// A weak reference to an object of type T, where T has base wxTrackable

 // (usually statically but if not dynamic_cast<> is tried).
 template <class T>
 class wxWeakRef : public
 // (usually statically but if not dynamic_cast<> is tried).
 template <class T>
 class wxWeakRef : public

-#ifdef HAVE_PARTIAL_SPECIALIZATION
-                  wxWeakRefImpl<T, wxIsStaticTrackable<T>::value>
-#else
+#ifdef USE_ONLY_STATIC_WEAKREF

                   wxWeakRefStatic<T>
                   wxWeakRefStatic<T>

+#else
+                  wxWeakRefImpl<T, wxIsStaticTrackable<T>::value != 0>

 #endif
 {
 public:
 #endif
 {
 public:

+    typedef T element_type;
+

     // Default ctor
     wxWeakRef() { }
 
     // Default ctor
     wxWeakRef() { }
 

+    // Enabling this ctor for VC6 results in mysterious compilation failures in
+    // wx/window.h when assigning wxWindow pointers (FIXME-VC6)
+#ifndef __VISUALC6__
+    // Ctor from the object of this type: this is needed as the template ctor
+    // below is not used by at least g++4 when a literal NULL is used
+    wxWeakRef(T *pobj)
+    {
+        this->Assign(pobj);
+    }
+#endif // !__VISUALC6__
+

     // When we have the full type here, static_cast<> will always work
     // (or give a straight compiler error).
     template <class TDerived>
     // When we have the full type here, static_cast<> will always work
     // (or give a straight compiler error).
     template <class TDerived>


@@ -194,30 +230,32 @@ public:
         Assign(pobj);
     }
 
         Assign(pobj);
     }
 

-    template <class TDerived>
-    wxWeakRef<T>& operator=(TDerived* pobj)
+    // We need this copy ctor, since otherwise a default compiler (binary) copy
+    // happens (if embedded as an object member).
+    wxWeakRef(const wxWeakRef<T>& wr)

     {
     {

-        Assign(pobj);
-        return *this;
+        Assign(wr.get());

     }
 
     wxWeakRef<T>& operator=(const wxWeakRef<T>& wr)
     {
     }
 
     wxWeakRef<T>& operator=(const wxWeakRef<T>& wr)
     {

-        AssignCopy(wr);
+        this->AssignCopy(wr);

         return *this;
     }
 
     virtual ~wxWeakRef() { this->Release(); }
 
     // Smart pointer functions
         return *this;
     }
 
     virtual ~wxWeakRef() { this->Release(); }
 
     // Smart pointer functions

-    T& operator*() const { return *this->m_pobj; }
-    T* operator->() const { return this->m_pobj; }
+    T& operator*() const    { return *this->m_pobj; }
+    T* operator->() const   { return this->m_pobj; }

 
 

-    T* get() const { return this->m_pobj; }
-    operator T*() const { return get(); }
+    T* get() const          { return this->m_pobj; }
+    operator T*() const     { return this->m_pobj; }

 };
 
 
 };
 
 

+#ifndef wxNO_RTTI
+

 // Weak ref implementation assign objects are queried for wxTrackable
 // using dynamic_cast<>
 template <class T>
 // Weak ref implementation assign objects are queried for wxTrackable
 // using dynamic_cast<>
 template <class T>


@@ -231,27 +269,24 @@ public:
         Assign(pobj);
     }
 
         Assign(pobj);
     }
 

+    wxWeakRefDynamic(const wxWeakRef<T>& wr)
+    {
+        Assign(wr.get());
+    }
+

     virtual ~wxWeakRefDynamic() { Release(); }
 
     // Smart pointer functions
     virtual ~wxWeakRefDynamic() { Release(); }
 
     // Smart pointer functions

-    T& operator * (){ wxASSERT(this->m_pobj); return *m_pobj; }
-    T* operator -> (){ wxASSERT(this->m_pobj); return m_pobj; }
-    T* operator = (T* pobj) { Assign(pobj); return m_pobj; }
+    T& operator*() const    { wxASSERT(m_pobj); return *m_pobj; }
+    T* operator->() const   { wxASSERT(m_pobj); return m_pobj; }

 
 

-    T* get(){ return this->m_pobj; }
+    T* get() const          { return m_pobj; }
+    operator T* () const    { return m_pobj; }

 
 

-    // operator T* (){ return this->m_pobj; }
-
-    // test for pointer validity: defining conversion to unspecified_bool_type
-    // and not more obvious bool to avoid implicit conversions to integer types
-    typedef T *(wxWeakRef<T>::*unspecified_bool_type)() const;
-    operator unspecified_bool_type() const
-    {
-        return m_pobj ? &wxWeakRef<T>::get : NULL;
-    }
+    T* operator = (T* pobj) { Assign(pobj); return m_pobj; }

 
     // Assign from another weak ref, point to same object
 
     // Assign from another weak ref, point to same object

-    T* operator = (const wxWeakRef<T> &wr) { Assign( wr.get() ); return this->m_pobj; }
+    T* operator = (const wxWeakRef<T> &wr) { Assign( wr.get() ); return m_pobj; }

 
     void Release()
     {
 
     void Release()
     {


@@ -266,6 +301,13 @@ public:
         }
     }
 
         }
     }
 

+    virtual void OnObjectDestroy()
+    {
+        wxASSERT_MSG(m_pobj, "tracked object should have removed us itself");
+
+        m_pobj = NULL;
+    }
+

 protected:
     void Assign(T *pobj)
     {
 protected:
     void Assign(T *pobj)
     {


@@ -293,20 +335,17 @@ protected:
         }
     }
 
         }
     }
 

-    virtual void OnObjectDestroy()
-    {
-        wxASSERT_MSG( m_pobj, "tracked object should have removed us itself" );
-
-        m_pobj = NULL;
-    }
-

     T *m_pobj;
 };
 
     T *m_pobj;
 };
 

+#endif // RTTI enabled
+
+

 // Provide some basic types of weak references
 class WXDLLIMPEXP_FWD_BASE wxEvtHandler;
 class WXDLLIMPEXP_FWD_CORE wxWindow;
 
 // Provide some basic types of weak references
 class WXDLLIMPEXP_FWD_BASE wxEvtHandler;
 class WXDLLIMPEXP_FWD_CORE wxWindow;
 

+

 typedef wxWeakRef<wxEvtHandler>  wxEvtHandlerRef;
 typedef wxWeakRef<wxWindow>      wxWindowRef;
 
 typedef wxWeakRef<wxEvtHandler>  wxEvtHandlerRef;
 typedef wxWeakRef<wxWindow>      wxWindowRef;