Warning fixes, source cleaning.

[wxWidgets.git] / contrib / src / fl / garbagec.cpp

diff --git a/contrib/src/fl/garbagec.cpp b/contrib/src/fl/garbagec.cpp
index 049f944e93dc00f443ad284291aa9bc43f5a4128..e0f95d02f51c37fcec21e4aa5512ab8f2114a870 100644 (file)
--- a/contrib/src/fl/garbagec.cpp
+++ b/contrib/src/fl/garbagec.cpp
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        No names yet.
-// Purpose:     Contrib. demo
+// Name:        garbagec.cpp
+// Purpose:     Garbage collection algorithm for optimizing refresh.

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

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

 /////////////////////////////////////////////////////////////////////////////
 
 
 /////////////////////////////////////////////////////////////////////////////
 
 


@@ -32,193 +32,190 @@
 
 inline static GCItem& node_to_item( wxNode* pNode )
 {
 
 inline static GCItem& node_to_item( wxNode* pNode )
 {

-       return *( (GCItem*)(pNode->Data()) );
+    return *( (GCItem*)(pNode->GetData()) );

 }
 
 GarbageCollector::~GarbageCollector()
 {
 }
 
 GarbageCollector::~GarbageCollector()
 {

-       Reset();
+    Reset();

 }
 
 /*** GC alg. helpers ***/
 
 void GarbageCollector::DestroyItemList( wxList& lst )
 {
 }
 
 /*** GC alg. helpers ***/
 
 void GarbageCollector::DestroyItemList( wxList& lst )
 {

-       wxNode* pNode = lst.First();
+    wxNode* pNode = lst.GetFirst();

 
 

-       while( pNode )
-       {
-               delete &node_to_item( pNode );
+    while( pNode )
+    {
+        delete &node_to_item( pNode );

 
 

-               pNode = pNode->Next();
-       }
+        pNode = pNode->GetNext();
+    }

 
 

-       lst.Clear();
+    lst.Clear();

 }
 
 wxNode* GarbageCollector::FindItemNode( void* pForObj )
 {
 }
 
 wxNode* GarbageCollector::FindItemNode( void* pForObj )
 {

-       wxNode* pNode = mAllNodes.First();
+    wxNode* pNode = mAllNodes.GetFirst();

 
 

-       while( pNode )
-       {
-               if ( node_to_item( pNode ).mpObj == pForObj )
+    while( pNode )
+    {
+        if ( node_to_item( pNode ).mpObj == pForObj )

 
 

-                       return pNode;
+            return pNode;

 
 

-               pNode = pNode->Next();
-       }
+        pNode = pNode->GetNext();
+    }

 
 

-       int avoidCompilerWarning = 0;
-       wxASSERT(avoidCompilerWarning); // DBG:: item should be present
-
-       return 0;
+    return NULL;

 }
 
 wxNode* GarbageCollector::FindReferenceFreeItemNode()
 {
 }
 
 wxNode* GarbageCollector::FindReferenceFreeItemNode()
 {

-       wxNode* pNode = mAllNodes.First();
+    wxNode* pNode = mAllNodes.GetFirst();

 
 

-       while( pNode )
-       {
-               if ( node_to_item( pNode ).mRefs.Number() == 0 ) 
+    while( pNode )
+    {
+        if ( node_to_item( pNode ).mRefs.GetCount() == 0 ) 

 
 

-                       return pNode;
+            return pNode;

 
 

-               pNode = pNode->Next();
-       }
+        pNode = pNode->GetNext();
+    }

 
 

-       return 0;
+    return 0;

 }
 
 void GarbageCollector::RemoveReferencesToNode( wxNode* pItemNode )
 {
 }
 
 void GarbageCollector::RemoveReferencesToNode( wxNode* pItemNode )
 {

-       wxNode* pNode = mAllNodes.First();
+    wxNode* pNode = mAllNodes.GetFirst();

 
 

-       while( pNode )
-       {
-               wxList& refLst   = node_to_item( pNode ).mRefs;
-               wxNode* pRefNode = refLst.First();
+    while( pNode )
+    {
+        wxList& refLst   = node_to_item( pNode ).mRefs;
+        wxNode* pRefNode = refLst.GetFirst();

 
 

-               while( pRefNode )
-               {
-                       if ( pRefNode->Data() == (wxObject*)pItemNode )
-                       {
-                               wxNode* pNext = pRefNode->Next();
+        while( pRefNode )
+        {
+            if ( pRefNode->GetData() == (wxObject*)pItemNode )
+            {
+                wxNode* pNext = pRefNode->GetNext();

 
 

-                               refLst.DeleteNode( pRefNode );
+                refLst.DeleteNode( pRefNode );

 
 

-                               pRefNode = pNext;
+                pRefNode = pNext;

 
 

-                               continue;
-                       }
-                       else pRefNode = pRefNode->Next();
-               }
+                continue;
+            }
+            else pRefNode = pRefNode->GetNext();
+        }

 
 

-               pNode = pNode->Next();
-       }
+        pNode = pNode->GetNext();
+    }

 }
 
 void GarbageCollector::ResolveReferences()
 {
 }
 
 void GarbageCollector::ResolveReferences()
 {

-       wxNode* pNode = mAllNodes.First();
+    wxNode* pNode = mAllNodes.GetFirst();

 
 

-       while( pNode )
-       {
-               GCItem& item = node_to_item( pNode );
+    while( pNode )
+    {
+        GCItem& item = node_to_item( pNode );

 
 

-               wxNode* pRefNode = item.mRefs.First();
+        wxNode* pRefNode = item.mRefs.GetFirst();

 
 

-               while( pRefNode )
-               {
-                       pRefNode->SetData( (wxObject*) FindItemNode( (void*)pRefNode->Data() ) );
+        while( pRefNode )
+        {
+            pRefNode->SetData( (wxObject*) FindItemNode( (void*)pRefNode->GetData() ) );

 
 

-                       pRefNode = pRefNode->Next();
-               }
+            pRefNode = pRefNode->GetNext();
+        }

 
 

-               pNode = pNode->Next();
-       }
+        pNode = pNode->GetNext();
+    }

 }
 
 }
 

-void GarbageCollector::AddObject( void* pObj, int refCnt )
+void GarbageCollector::AddObject( void* pObj, int WXUNUSED(refCnt) )

 {
 {

-       // FOR NOW:: initial ref-count is not used
+    // FOR NOW:: initial ref-count is not used

 
 

-       GCItem* pItem = new GCItem();
+    GCItem* pItem = new GCItem();

 
 

-       pItem->mpObj  = pObj;
+    pItem->mpObj  = pObj;

 
 

-       mAllNodes.Append( (wxObject*) pItem );
+    mAllNodes.Append( (wxObject*) pItem );

 }
 
 void GarbageCollector::AddDependency( void* pObj, void* pDependsOnObj )
 {
 }
 
 void GarbageCollector::AddDependency( void* pObj, void* pDependsOnObj )
 {

-       node_to_item( FindItemNode( pObj ) ).mRefs.Append( (wxObject*)pDependsOnObj );
+    node_to_item( FindItemNode( pObj ) ).mRefs.Append( (wxObject*)pDependsOnObj );

 }
 
 /*** GC alg. implementation ***/
 
 void GarbageCollector::ArrangeCollection()
 {
 }
 
 /*** GC alg. implementation ***/
 
 void GarbageCollector::ArrangeCollection()
 {

-       ResolveReferences();
+    ResolveReferences();

 
 

-       do
-       {
-               // find node, which does not depend on anything
+    do
+    {
+        // find node, which does not depend on anything

 
 

-               wxNode* pItemNode = FindReferenceFreeItemNode();
+        wxNode* pItemNode = FindReferenceFreeItemNode();

 
 

-               if ( pItemNode )
-               {
-                       // append it to the list, where items are contained
-                       // in the increasing order of dependencies
+        if ( pItemNode )
+        {
+            // append it to the list, where items are contained
+            // in the increasing order of dependencies

 
 

-                       mRegularLst.Append( pItemNode->Data() );
+            mRegularLst.Append( pItemNode->GetData() );

 
 

-                       mAllNodes.DeleteNode( pItemNode );
+            mAllNodes.DeleteNode( pItemNode );

 
 

-                       // remove references to this current "least-dependent" node
-                       // from reference lists of all the other nodes
+            // remove references to this current "least-dependent" node
+            // from reference lists of all the other nodes

 
 

-                       RemoveReferencesToNode( pItemNode );
-               }
-               else
-               {
-                       // otherwise, what is left - all nodes, which
-                       // are involved into cycled chains (rings)
+            RemoveReferencesToNode( pItemNode );
+        }
+        else
+        {
+            // otherwise, what is left - all nodes, which
+            // are involved into cycled chains (rings)

 
 

-                       wxNode* pNode = mAllNodes.First();
+            wxNode* pNode = mAllNodes.GetFirst();

 
 

-                       while( pNode )
-                       {
-                               mCycledLst.Append( pNode->Data() );
+            while( pNode )
+            {
+                mCycledLst.Append( pNode->GetData() );

 
 

-                               pNode = pNode->Next();
-                       }
+                pNode = pNode->GetNext();
+            }

 
 

-                       break;
-               }
+            mAllNodes.Clear();
+            break;
+        }

 
 

-               // continue search for "least-dependent" nodes
+        // continue search for "least-dependent" nodes

 
 

-       } while(1);
+    } while(1);

 }
 
 wxList& GarbageCollector::GetRegularObjects()
 {
 }
 
 wxList& GarbageCollector::GetRegularObjects()
 {

-       return mRegularLst;
+    return mRegularLst;

 }
 
 wxList& GarbageCollector::GetCycledObjects()
 {
 }
 
 wxList& GarbageCollector::GetCycledObjects()
 {

-       return mCycledLst;
+    return mCycledLst;

 }
 
 void GarbageCollector::Reset()
 {
 }
 
 void GarbageCollector::Reset()
 {

-       DestroyItemList( mAllNodes   );
-
-       mRegularLst.Clear();
-       mCycledLst.Clear();
+    DestroyItemList( mAllNodes   );
+    DestroyItemList( mRegularLst );
+    DestroyItemList( mCycledLst );

 }
 
 }