corrected assert even better

[wxWidgets.git] / contrib / include / wx / fl / gcupdatesmgr.h

diff --git a/contrib/include/wx/fl/gcupdatesmgr.h b/contrib/include/wx/fl/gcupdatesmgr.h
index e8fabc5acc4808d876541575bf2d624d25194610..544e43ea231b8b05bd872eaa6bc20f5f100b0bec 100644 (file)
--- a/contrib/include/wx/fl/gcupdatesmgr.h
+++ b/contrib/include/wx/fl/gcupdatesmgr.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        No names yet.
-// Purpose:     Contrib. demo
+// Name:        gcupdatesmgr.h
+// Purpose:     Header for cbGCUpdatesMgr class.

 // Author:      Aleksandras Gluchovas
 // Modified by:
 // Created:     19/10/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Aleksandras Gluchovas
 // Author:      Aleksandras Gluchovas
 // Modified by:
 // Created:     19/10/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Aleksandras Gluchovas

-// Licence:    wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef __GCUPDATESMGR_G__
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef __GCUPDATESMGR_G__


@@ -22,101 +22,107 @@
 #include "wx/fl/garbagec.h"
 
 /*
 #include "wx/fl/garbagec.h"
 
 /*

- * class implements optimized logic for refreshing
- * areas of frame layout - which actually need to be updated. 
- * Is used as default updates-manager by wxFrameLayout.
- *
- * it is called "Garbage Collecting" u.mgr for it's implementation
- * tries to find out dependencies between bars, and to order
- * them ito "hierarchy", this hierarchical sorting resembles
- * implemenation of heap-garbage collectors, which resolve
- * dependencies between references.
- *
- * Example: there are situations where the order of moving
- *          the windows does matter:
- *
- *   case 1)                
- *      ------             ---
- *      | A     |                  |B|  
- *             ------   --->   | |
- *                     ---                     --- ------ 
- *                     |B|                             | A  | 
- *                     | |                             ------
- *                     ---                             
- *                                             (future)
- *        (past)            
- *
- *  past/future positions of A and B windows completely overlapp, i.e.
- *  depend on each other, and there is not solution for
- *  moving the windows witout refreshing both of them,
- *  -- we have cyclic dependency here. The gc. alg will
- *  find this cyclic dependecy and will force "refresh"
- *  after movement.
- *
- *   case 2)
- *
- *      ------                                 
- *      | A     |                                      
- *             ------   --->                       
- *                     ---                               
- *                     |B|                                        ------   
- *                     | |                                        | A  |   
- *                     ---                                        ------         
- *                                              ---
- *                                              |B|
- *                                              | |
- *                                          ---
- *
- *                                             (future)                
- *        (past)       
- *
- *  in this case past/future positions do not overlapp, thus
- *  it's enough only to move windows, without refreshing them.
- *  GC will "notice" it.
- *
- *  there is also third case, when overlapping is partial
- *  in this case the refershing can be also avoided by
- *  moving windows in the order of "most-dependant" towards the
- *  "least-dependent". GC handles this automatically, by
- *  sorting windows by their dependency-level (or "hierarchy")
- *
- *  See garbagec.h for more details of this method, garbagec.h/cpp
- *  implement sorting of generic-dependencies (does not deal
- *  with graphical objects directly)
- *
- *  Summary: improves performance when complex/large windows are 
- *           moved around, by reducing number of repaints. Also helps 
- *           to avoid dirty non-client areas of moved windows
- *           in some special cases of "overlapping anomalies"
- */
+This class implements optimized logic for refreshing
+the areas of frame layout that actually need to be updated.
+It is used as the default updates manager by wxFrameLayout.
+
+It is called 'Garbage Collecting' updates manager because
+its implementation tries to find out dependencies between bars,
+and to order them into a 'hierarchy'. This hierarchical sorting resembles
+the implementation of heap-garbage collectors, which resolve
+dependencies between references.
+
+Example: there are situations where the order in which the user
+moves windows does matter.
+
+\begin{verbatim}
+  case 1)
+     ------            ---
+     | A     |             |B|
+        ------     --->      | |
+            ---               --- ------
+            |B|                   | A  |
+            | |                   ------
+            ---
+                        (future)
+       (past)
+\end{verbatim}
+
+Past/future positions of A and B windows completely overlap, i.e.
+depend on each other, and there is no solution for
+moving the windows without refreshing both of them
+-- we have a cyclic dependency here. The garbage collection algorithm will
+find this cyclic dependecy and will force refresh after movement.
+
+\begin{verbatim}
+  case 2)
+
+     ------
+     | A     |
+        ------     --->
+            ---
+            |B|                              ------
+            | |                              | A  |
+            ---                              ------
+                         ---
+                         |B|
+                         | |
+                         ---
+
+                        (future)
+       (past)
+\end{verbatim}
+
+In this case past/future positions do not overlap, so
+it is enough only to move windows without refreshing them.
+Garbage collection will 'notice' this.
+
+There is also a third case, when overlapping is partial.
+In this case the refreshing can also be avoided by
+moving windows in the order of 'most-dependant' towards the
+'least-dependent'. GC handles this automatically, by
+sorting windows by their dependency-level (or 'hierarchy').
+
+See garbagec.h for more details of this method; garbagec.h/cpp
+implement sorting of generic dependencies and does not deal
+with graphical objects directly.
+
+Summary: garbage collection improves performance when complex or large
+windows are moved around, by reducing the number of repaints. It also helps
+to avoid dirty non-client areas of moved windows
+in some special cases of 'overlapping anomalies'.
+*/

 
 class cbGCUpdatesMgr : public cbSimpleUpdatesMgr
 {
 
 class cbGCUpdatesMgr : public cbSimpleUpdatesMgr
 {

-       DECLARE_DYNAMIC_CLASS( cbGCUpdatesMgr )
+    DECLARE_DYNAMIC_CLASS( cbGCUpdatesMgr )

 protected:
 
 protected:
 

-       GarbageCollector mGC;
+    GarbageCollector mGC;

 
 

-       void DoRepositionItems( wxList& items );
+        // Internal function for repositioning items.
+    void DoRepositionItems( wxList& items );

 
 

-       void AddItem( wxList&     itemList,
-                                 cbBarInfo*  pBar, 
-                         cbDockPane* pPane,
-                                 wxRect&     curBounds,
-                                 wxRect&     prevBounds );
+        // Internal function for repositioning items.
+    void AddItem( wxList&     itemList,
+                  cbBarInfo*  pBar,
+                  cbDockPane* pPane,
+                  wxRect&     curBounds,
+                  wxRect&     prevBounds );

 
 public:
 
 
 public:
 

-       cbGCUpdatesMgr(void) {}
+        // Default constructor.
+    cbGCUpdatesMgr(void) {}

 
 

-       cbGCUpdatesMgr( wxFrameLayout* pPanel );
+        // Constructor, taking a frame layout.
+    cbGCUpdatesMgr( wxFrameLayout* pPanel );

 
 

-       // notificiactions received from Frame Layout :
+        // Receives notifications from the frame layout.
+    virtual void OnStartChanges();

 
 

-       virtual void OnStartChanges();
-
-       // refreshes parts of the frame layout, which need an update
-       virtual void UpdateNow();
+        // Refreshes the parts of the frame layout which need an update.
+    virtual void UpdateNow();

 };
 
 #endif /* __GCUPDATESMGR_G__ */
 };
 
 #endif /* __GCUPDATESMGR_G__ */