Add another test for the insertion point position after SetValue().

[wxWidgets.git] / src / common / gdicmn.cpp

diff --git a/src/common/gdicmn.cpp b/src/common/gdicmn.cpp
index d8cb7546322cd83936f949c88d2e7ede48f9e614..e87361656b39dcdfac7d7c6a72f2077f2bba0ee5 100644 (file)
--- a/src/common/gdicmn.cpp
+++ b/src/common/gdicmn.cpp
@@ -17,6 +17,7 @@
 #endif
 
 #include "wx/gdicmn.h"
 #endif
 
 #include "wx/gdicmn.h"

+#include "wx/gdiobj.h"

 
 #ifndef WX_PRECOMP
     #include "wx/log.h"
 
 #ifndef WX_PRECOMP
     #include "wx/log.h"


@@ -24,13 +25,19 @@
     #include "wx/brush.h"
     #include "wx/palette.h"
     #include "wx/icon.h"
     #include "wx/brush.h"
     #include "wx/palette.h"
     #include "wx/icon.h"

+    #include "wx/iconbndl.h"

     #include "wx/cursor.h"
     #include "wx/settings.h"
     #include "wx/bitmap.h"
     #include "wx/colour.h"
     #include "wx/font.h"
     #include "wx/cursor.h"
     #include "wx/settings.h"
     #include "wx/bitmap.h"
     #include "wx/colour.h"
     #include "wx/font.h"

+    #include "wx/math.h"

 #endif
 
 #endif
 

+
+IMPLEMENT_ABSTRACT_CLASS(wxGDIObject, wxObject)
+
+

 WXDLLIMPEXP_DATA_CORE(wxBrushList*) wxTheBrushList;
 WXDLLIMPEXP_DATA_CORE(wxFontList*)  wxTheFontList;
 WXDLLIMPEXP_DATA_CORE(wxPenList*)   wxThePenList;
 WXDLLIMPEXP_DATA_CORE(wxBrushList*) wxTheBrushList;
 WXDLLIMPEXP_DATA_CORE(wxFontList*)  wxTheFontList;
 WXDLLIMPEXP_DATA_CORE(wxPenList*)   wxThePenList;


@@ -47,10 +54,15 @@ WXDLLIMPEXP_DATA_CORE(wxPen)     wxNullPen;
 #if wxUSE_PALETTE
 WXDLLIMPEXP_DATA_CORE(wxPalette) wxNullPalette;
 #endif
 #if wxUSE_PALETTE
 WXDLLIMPEXP_DATA_CORE(wxPalette) wxNullPalette;
 #endif

+WXDLLIMPEXP_DATA_CORE(wxIconBundle) wxNullIconBundle;

 
 const wxSize wxDefaultSize(wxDefaultCoord, wxDefaultCoord);
 const wxPoint wxDefaultPosition(wxDefaultCoord, wxDefaultCoord);
 
 
 const wxSize wxDefaultSize(wxDefaultCoord, wxDefaultCoord);
 const wxPoint wxDefaultPosition(wxDefaultCoord, wxDefaultCoord);
 

+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxPointList)
+
+

 #if wxUSE_EXTENDED_RTTI
 
 // wxPoint
 #if wxUSE_EXTENDED_RTTI
 
 // wxPoint


@@ -103,23 +115,6 @@ wxRect::wxRect(const wxPoint& point1, const wxPoint& point2)
     height++;
 }
 
     height++;
 }
 

-bool wxRect::operator==(const wxRect& rect) const
-{
-    return ((x == rect.x) &&
-            (y == rect.y) &&
-            (width == rect.width) &&
-            (height == rect.height));
-}
-
-wxRect wxRect::operator+(const wxRect& rect) const
-{
-    int x1 = wxMin(this->x, rect.x);
-    int y1 = wxMin(this->y, rect.y);
-    int y2 = wxMax(y+height, rect.height+rect.y);
-    int x2 = wxMax(x+width, rect.width+rect.x);
-    return wxRect(x1, y1, x2-x1, y2-y1);
-}
-

 wxRect& wxRect::Union(const wxRect& rect)
 {
     // ignore empty rectangles: union with an empty rectangle shouldn't extend
 wxRect& wxRect::Union(const wxRect& rect)
 {
     // ignore empty rectangles: union with an empty rectangle shouldn't extend


@@ -178,7 +173,7 @@ wxRect& wxRect::Inflate(wxCoord dx, wxCoord dy)
     return *this;
 }
 
     return *this;
 }
 

-bool wxRect::Inside(int cx, int cy) const
+bool wxRect::Contains(int cx, int cy) const

 {
     return ( (cx >= x) && (cy >= y)
           && ((cy - y) < height)
 {
     return ( (cx >= x) && (cy >= y)
           && ((cy - y) < height)


@@ -186,9 +181,9 @@ bool wxRect::Inside(int cx, int cy) const
           );
 }
 
           );
 }
 

-bool wxRect::Inside(const wxRect& rect) const
+bool wxRect::Contains(const wxRect& rect) const

 {
 {

-    return Inside(rect.GetTopLeft()) && Inside(rect.GetBottomRight());
+    return Contains(rect.GetTopLeft()) && Contains(rect.GetBottomRight());

 }
 
 wxRect& wxRect::Intersect(const wxRect& rect)
 }
 
 wxRect& wxRect::Intersect(const wxRect& rect)


@@ -225,6 +220,43 @@ bool wxRect::Intersects(const wxRect& rect) const
     return r.width != 0;
 }
 
     return r.width != 0;
 }
 

+wxRect& wxRect::operator+=(const wxRect& rect)
+{
+    *this = *this + rect;
+    return *this;
+}
+
+
+wxRect& wxRect::operator*=(const wxRect& rect)
+{
+    *this = *this * rect;
+    return *this;
+}
+
+
+wxRect operator+(const wxRect& r1, const wxRect& r2)
+{
+    int x1 = wxMin(r1.x, r2.x);
+    int y1 = wxMin(r1.y, r2.y);
+    int y2 = wxMax(r1.y+r1.height, r2.height+r2.y);
+    int x2 = wxMax(r1.x+r1.width, r2.width+r2.x);
+    return wxRect(x1, y1, x2-x1, y2-y1);
+}
+
+wxRect operator*(const wxRect& r1, const wxRect& r2)
+{
+    int x1 = wxMax(r1.x, r2.x);
+    int y1 = wxMax(r1.y, r2.y);
+    int y2 = wxMin(r1.y+r1.height, r2.height+r2.y);
+    int x2 = wxMin(r1.x+r1.width, r2.width+r2.x);
+    return wxRect(x1, y1, x2-x1, y2-y1);
+}
+
+wxRealPoint::wxRealPoint(const wxPoint& pt)
+ : x(pt.x), y(pt.y)
+{
+}
+

 // ============================================================================
 // wxColourDatabase
 // ============================================================================
 // ============================================================================
 // wxColourDatabase
 // ============================================================================


@@ -322,7 +354,7 @@ void wxColourDatabase::Initialize()
         {wxT("ORANGE RED"), 255, 0, 127},
         {wxT("ORCHID"), 219, 112, 219},
         {wxT("PALE GREEN"), 143, 188, 143},
         {wxT("ORANGE RED"), 255, 0, 127},
         {wxT("ORCHID"), 219, 112, 219},
         {wxT("PALE GREEN"), 143, 188, 143},

-        {wxT("PINK"), 188, 143, 234},
+        {wxT("PINK"), 255, 192, 203},

         {wxT("PLUM"), 234, 173, 234},
         {wxT("PURPLE"), 176, 0, 255},
         {wxT("RED"), 255, 0, 0},
         {wxT("PLUM"), 234, 173, 234},
         {wxT("PURPLE"), 176, 0, 255},
         {wxT("RED"), 255, 0, 0},


@@ -378,7 +410,7 @@ void wxColourDatabase::AddColour(const wxString& name, const wxColour& colour)
 
     // ... and we also allow both grey/gray
     wxString colNameAlt = colName;
 
     // ... and we also allow both grey/gray
     wxString colNameAlt = colName;

-    if ( !colNameAlt.Replace(_T("GRAY"), _T("GREY")) )
+    if ( !colNameAlt.Replace(wxT("GRAY"), wxT("GREY")) )

     {
         // but in this case it is not necessary so avoid extra search below
         colNameAlt.clear();
     {
         // but in this case it is not necessary so avoid extra search below
         colNameAlt.clear();


@@ -406,7 +438,7 @@ wxColour wxColourDatabase::Find(const wxString& colour) const
     wxString colName = colour;
     colName.MakeUpper();
     wxString colNameAlt = colName;
     wxString colName = colour;
     colName.MakeUpper();
     wxString colNameAlt = colName;

-    if ( !colNameAlt.Replace(_T("GRAY"), _T("GREY")) )
+    if ( !colNameAlt.Replace(wxT("GRAY"), wxT("GREY")) )

         colNameAlt.clear();
 
     wxStringToColourHashMap::iterator it = m_map->find(colName);
         colNameAlt.clear();
 
     wxStringToColourHashMap::iterator it = m_map->find(colName);


@@ -494,47 +526,49 @@ void wxStockGDI::DeleteAll()
 {
     for (unsigned i = 0; i < ITEMCOUNT; i++)
     {
 {
     for (unsigned i = 0; i < ITEMCOUNT; i++)
     {

-        delete ms_stockObject[i];
-        ms_stockObject[i] = NULL;
+        wxDELETE(ms_stockObject[i]);

     }
 }
 
 const wxBrush* wxStockGDI::GetBrush(Item item)
 {
     }
 }
 
 const wxBrush* wxStockGDI::GetBrush(Item item)
 {

-    wxBrush* brush = wx_static_cast(wxBrush*, ms_stockObject[item]);
+    wxBrush* brush = static_cast<wxBrush*>(ms_stockObject[item]);

     if (brush == NULL)
     {
         switch (item)
         {
         case BRUSH_BLACK:
     if (brush == NULL)
     {
         switch (item)
         {
         case BRUSH_BLACK:

-            brush = new wxBrush(*GetColour(COLOUR_BLACK), wxSOLID);
+            brush = new wxBrush(*GetColour(COLOUR_BLACK), wxBRUSHSTYLE_SOLID);

             break;
         case BRUSH_BLUE:
             break;
         case BRUSH_BLUE:

-            brush = new wxBrush(*GetColour(COLOUR_BLUE), wxSOLID);
+            brush = new wxBrush(*GetColour(COLOUR_BLUE), wxBRUSHSTYLE_SOLID);

             break;
         case BRUSH_CYAN:
             break;
         case BRUSH_CYAN:

-            brush = new wxBrush(*GetColour(COLOUR_CYAN), wxSOLID);
+            brush = new wxBrush(*GetColour(COLOUR_CYAN), wxBRUSHSTYLE_SOLID);

             break;
         case BRUSH_GREEN:
             break;
         case BRUSH_GREEN:

-            brush = new wxBrush(*GetColour(COLOUR_GREEN), wxSOLID);
+            brush = new wxBrush(*GetColour(COLOUR_GREEN), wxBRUSHSTYLE_SOLID);
+            break;
+        case BRUSH_YELLOW:
+            brush = new wxBrush(*GetColour(COLOUR_YELLOW), wxBRUSHSTYLE_SOLID);

             break;
         case BRUSH_GREY:
             break;
         case BRUSH_GREY:

-            brush = new wxBrush(wxColour(wxT("GREY")), wxSOLID);
+            brush = new wxBrush(wxColour(wxT("GREY")), wxBRUSHSTYLE_SOLID);

             break;
         case BRUSH_LIGHTGREY:
             break;
         case BRUSH_LIGHTGREY:

-            brush = new wxBrush(*GetColour(COLOUR_LIGHTGREY), wxSOLID);
+            brush = new wxBrush(*GetColour(COLOUR_LIGHTGREY), wxBRUSHSTYLE_SOLID);

             break;
         case BRUSH_MEDIUMGREY:
             break;
         case BRUSH_MEDIUMGREY:

-            brush = new wxBrush(wxColour(wxT("MEDIUM GREY")), wxSOLID);
+            brush = new wxBrush(wxColour(wxT("MEDIUM GREY")), wxBRUSHSTYLE_SOLID);

             break;
         case BRUSH_RED:
             break;
         case BRUSH_RED:

-            brush = new wxBrush(*GetColour(COLOUR_RED), wxSOLID);
+            brush = new wxBrush(*GetColour(COLOUR_RED), wxBRUSHSTYLE_SOLID);

             break;
         case BRUSH_TRANSPARENT:
             break;
         case BRUSH_TRANSPARENT:

-            brush = new wxBrush(*GetColour(COLOUR_BLACK), wxTRANSPARENT);
+            brush = new wxBrush(*GetColour(COLOUR_BLACK), wxBRUSHSTYLE_TRANSPARENT);

             break;
         case BRUSH_WHITE:
             break;
         case BRUSH_WHITE:

-            brush = new wxBrush(*GetColour(COLOUR_WHITE), wxSOLID);
+            brush = new wxBrush(*GetColour(COLOUR_WHITE), wxBRUSHSTYLE_SOLID);

             break;
         default:
             wxFAIL;
             break;
         default:
             wxFAIL;


@@ -546,7 +580,7 @@ const wxBrush* wxStockGDI::GetBrush(Item item)
 
 const wxColour* wxStockGDI::GetColour(Item item)
 {
 
 const wxColour* wxStockGDI::GetColour(Item item)
 {

-    wxColour* colour = wx_static_cast(wxColour*, ms_stockObject[item]);
+    wxColour* colour = static_cast<wxColour*>(ms_stockObject[item]);

     if (colour == NULL)
     {
         switch (item)
     if (colour == NULL)
     {
         switch (item)


@@ -563,6 +597,9 @@ const wxColour* wxStockGDI::GetColour(Item item)
         case COLOUR_GREEN:
             colour = new wxColour(0, 255, 0);
             break;
         case COLOUR_GREEN:
             colour = new wxColour(0, 255, 0);
             break;

+        case COLOUR_YELLOW:
+            colour = new wxColour(255, 255, 0);
+            break;

         case COLOUR_LIGHTGREY:
             colour = new wxColour(wxT("LIGHT GREY"));
             break;
         case COLOUR_LIGHTGREY:
             colour = new wxColour(wxT("LIGHT GREY"));
             break;


@@ -582,7 +619,7 @@ const wxColour* wxStockGDI::GetColour(Item item)
 
 const wxCursor* wxStockGDI::GetCursor(Item item)
 {
 
 const wxCursor* wxStockGDI::GetCursor(Item item)
 {

-    wxCursor* cursor = wx_static_cast(wxCursor*, ms_stockObject[item]);
+    wxCursor* cursor = static_cast<wxCursor*>(ms_stockObject[item]);

     if (cursor == NULL)
     {
         switch (item)
     if (cursor == NULL)
     {
         switch (item)


@@ -606,7 +643,7 @@ const wxCursor* wxStockGDI::GetCursor(Item item)
 
 const wxFont* wxStockGDI::GetFont(Item item)
 {
 
 const wxFont* wxStockGDI::GetFont(Item item)
 {

-    wxFont* font = wx_static_cast(wxFont*, ms_stockObject[item]);
+    wxFont* font = static_cast<wxFont*>(ms_stockObject[item]);

     if (font == NULL)
     {
         switch (item)
     if (font == NULL)
     {
         switch (item)


@@ -633,40 +670,46 @@ const wxFont* wxStockGDI::GetFont(Item item)
 
 const wxPen* wxStockGDI::GetPen(Item item)
 {
 
 const wxPen* wxStockGDI::GetPen(Item item)
 {

-    wxPen* pen = wx_static_cast(wxPen*, ms_stockObject[item]);
+    wxPen* pen = static_cast<wxPen*>(ms_stockObject[item]);

     if (pen == NULL)
     {
         switch (item)
         {
         case PEN_BLACK:
     if (pen == NULL)
     {
         switch (item)
         {
         case PEN_BLACK:

-            pen = new wxPen(*GetColour(COLOUR_BLACK), 1, wxSOLID);
+            pen = new wxPen(*GetColour(COLOUR_BLACK), 1, wxPENSTYLE_SOLID);

             break;
         case PEN_BLACKDASHED:
             break;
         case PEN_BLACKDASHED:

-            pen = new wxPen(*GetColour(COLOUR_BLACK), 1, wxSHORT_DASH);
+            pen = new wxPen(*GetColour(COLOUR_BLACK), 1, wxPENSTYLE_SHORT_DASH);
+            break;
+        case PEN_BLUE:
+            pen = new wxPen(*GetColour(COLOUR_BLUE), 1, wxPENSTYLE_SOLID);

             break;
         case PEN_CYAN:
             break;
         case PEN_CYAN:

-            pen = new wxPen(*GetColour(COLOUR_CYAN), 1, wxSOLID);
+            pen = new wxPen(*GetColour(COLOUR_CYAN), 1, wxPENSTYLE_SOLID);

             break;
         case PEN_GREEN:
             break;
         case PEN_GREEN:

-            pen = new wxPen(*GetColour(COLOUR_GREEN), 1, wxSOLID);
+            pen = new wxPen(*GetColour(COLOUR_GREEN), 1, wxPENSTYLE_SOLID);
+            break;
+        case PEN_YELLOW:
+            pen = new wxPen(*GetColour(COLOUR_YELLOW), 1, wxPENSTYLE_SOLID);

             break;
         case PEN_GREY:
             break;
         case PEN_GREY:

-            pen = new wxPen(wxColour(wxT("GREY")), 1, wxSOLID);
+            pen = new wxPen(wxColour(wxT("GREY")), 1, wxPENSTYLE_SOLID);

             break;
         case PEN_LIGHTGREY:
             break;
         case PEN_LIGHTGREY:

-            pen = new wxPen(*GetColour(COLOUR_LIGHTGREY), 1, wxSOLID);
+            pen = new wxPen(*GetColour(COLOUR_LIGHTGREY), 1, wxPENSTYLE_SOLID);

             break;
         case PEN_MEDIUMGREY:
             break;
         case PEN_MEDIUMGREY:

-            pen = new wxPen(wxColour(wxT("MEDIUM GREY")), 1, wxSOLID);
+            pen = new wxPen(wxColour(wxT("MEDIUM GREY")), 1, wxPENSTYLE_SOLID);

             break;
         case PEN_RED:
             break;
         case PEN_RED:

-            pen = new wxPen(*GetColour(COLOUR_RED), 1, wxSOLID);
+            pen = new wxPen(*GetColour(COLOUR_RED), 1, wxPENSTYLE_SOLID);

             break;
         case PEN_TRANSPARENT:
             break;
         case PEN_TRANSPARENT:

-            pen = new wxPen(*GetColour(COLOUR_BLACK), 1, wxTRANSPARENT);
+            pen = new wxPen(*GetColour(COLOUR_BLACK), 1, wxPENSTYLE_TRANSPARENT);

             break;
         case PEN_WHITE:
             break;
         case PEN_WHITE:

-            pen = new wxPen(*GetColour(COLOUR_WHITE), 1, wxSOLID);
+            pen = new wxPen(*GetColour(COLOUR_WHITE), 1, wxPENSTYLE_SOLID);

             break;
         default:
             wxFAIL;
             break;
         default:
             wxFAIL;


@@ -690,6 +733,8 @@ void wxDeleteStockLists()
     wxDELETE(wxTheBrushList);
     wxDELETE(wxThePenList);
     wxDELETE(wxTheFontList);
     wxDELETE(wxTheBrushList);
     wxDELETE(wxThePenList);
     wxDELETE(wxTheFontList);

+
+    // wxTheColourDatabase is cleaned up by wxAppBase::CleanUp()

 }
 
 // ============================================================================
 }
 
 // ============================================================================


@@ -704,22 +749,21 @@ wxGDIObjListBase::~wxGDIObjListBase()
 {
     for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
     {
 {
     for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
     {

-        delete wx_static_cast(wxObject*, node->GetData());
+        delete static_cast<wxObject*>(node->GetData());

     }
 }
 
     }
 }
 

-wxPen *wxPenList::FindOrCreatePen (const wxColour& colour, int width, int style)
+wxPen *wxPenList::FindOrCreatePen (const wxColour& colour, int width, wxPenStyle style)

 {
 {

-    for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
+    for ( wxList::compatibility_iterator node = list.GetFirst();
+          node;
+          node = node->GetNext() )

     {
     {

-        wxPen *each_pen = (wxPen *) node->GetData ();
-        if (
-                each_pen->GetWidth () == width &&
-                each_pen->GetStyle () == style &&
-                each_pen->GetColour ().Red () == colour.Red () &&
-                each_pen->GetColour ().Green () == colour.Green () &&
-                each_pen->GetColour ().Blue () == colour.Blue ())
-            return each_pen;
+        wxPen * const pen = (wxPen *) node->GetData();
+        if ( pen->GetWidth () == width &&
+                pen->GetStyle () == style &&
+                    pen->GetColour() == colour )
+            return pen;

     }
 
     wxPen* pen = NULL;
     }
 
     wxPen* pen = NULL;


@@ -733,17 +777,15 @@ wxPen *wxPenList::FindOrCreatePen (const wxColour& colour, int width, int style)
     return pen;
 }
 
     return pen;
 }
 

-wxBrush *wxBrushList::FindOrCreateBrush (const wxColour& colour, int style)
+wxBrush *wxBrushList::FindOrCreateBrush (const wxColour& colour, wxBrushStyle style)

 {
 {

-    for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
+    for ( wxList::compatibility_iterator node = list.GetFirst();
+          node;
+          node = node->GetNext() )

     {
     {

-        wxBrush *each_brush = (wxBrush *) node->GetData ();
-        if (
-                each_brush->GetStyle () == style &&
-                each_brush->GetColour ().Red () == colour.Red () &&
-                each_brush->GetColour ().Green () == colour.Green () &&
-                each_brush->GetColour ().Blue () == colour.Blue ())
-            return each_brush;
+        wxBrush * const brush = (wxBrush *) node->GetData ();
+        if ( brush->GetStyle() == style && brush->GetColour() == colour )
+            return brush;

     }
 
     wxBrush* brush = NULL;
     }
 
     wxBrush* brush = NULL;


@@ -758,9 +800,9 @@ wxBrush *wxBrushList::FindOrCreateBrush (const wxColour& colour, int style)
 }
 
 wxFont *wxFontList::FindOrCreateFont(int pointSize,
 }
 
 wxFont *wxFontList::FindOrCreateFont(int pointSize,

-                                     int family,
-                                     int style,
-                                     int weight,
+                                     wxFontFamily family,
+                                     wxFontStyle style,
+                                     wxFontWeight weight,

                                      bool underline,
                                      const wxString& facename,
                                      wxFontEncoding encoding)
                                      bool underline,
                                      const wxString& facename,
                                      wxFontEncoding encoding)


@@ -776,14 +818,14 @@ wxFont *wxFontList::FindOrCreateFont(int pointSize,
              font->GetWeight () == weight &&
              font->GetUnderlined () == underline )
         {
              font->GetWeight () == weight &&
              font->GetUnderlined () == underline )
         {

-            int fontFamily = font->GetFamily();
+            wxFontFamily fontFamily = (wxFontFamily)font->GetFamily();

 
 #if defined(__WXGTK__)
             // under GTK the default family is wxSWISS, so looking for a font
             // with wxDEFAULT family should return a wxSWISS one instead of
             // creating a new one
             bool same = (fontFamily == family) ||
 
 #if defined(__WXGTK__)
             // under GTK the default family is wxSWISS, so looking for a font
             // with wxDEFAULT family should return a wxSWISS one instead of
             // creating a new one
             bool same = (fontFamily == family) ||

-                        (fontFamily == wxSWISS && family == wxDEFAULT);
+                        (fontFamily == wxFONTFAMILY_SWISS && family == wxFONTFAMILY_DEFAULT);

 #else // !GTK
             // VZ: but why elsewhere do we require an exact match? mystery...
             bool same = fontFamily == family;
 #else // !GTK
             // VZ: but why elsewhere do we require an exact match? mystery...
             bool same = fontFamily == family;


@@ -857,6 +899,15 @@ wxSize wxGetDisplaySizeMM()
     return wxSize(x, y);
 }
 
     return wxSize(x, y);
 }
 

+wxSize wxGetDisplayPPI()
+{
+    const wxSize pixels = wxGetDisplaySize();
+    const wxSize mm = wxGetDisplaySizeMM();
+
+    return wxSize((int)((pixels.x * inches2mm) / mm.x),
+                  (int)((pixels.y * inches2mm) / mm.y));
+}
+

 wxResourceCache::~wxResourceCache ()
 {
     wxList::compatibility_iterator node = GetFirst ();
 wxResourceCache::~wxResourceCache ()
 {
     wxList::compatibility_iterator node = GetFirst ();