From ac5d21d27da4d5d009fbe55df9b1c0092e53934b Mon Sep 17 00:00:00 2001
From: Lars Kanis <kanis@comcard.de>
Date: Fri, 3 Feb 2012 20:38:40 +0100
Subject: [PATCH] Fix 'object allocation not allowed while garbage collection'
 bug

Calling any Ruby code within the mark phase is generelly dangerous,
because it usually allocates some objects.
Since most of the methods of FX objects can be overloaded in Ruby,
the calls in markfuncs now call explizitly the C++ methods.

Also remove some double marking of objects.
---
 ext/fox16/markfuncs.cpp | 416 ++++++++++++++++++++--------------------
 1 file changed, 204 insertions(+), 212 deletions(-)

diff --git a/ext/fox16/markfuncs.cpp b/ext/fox16/markfuncs.cpp
index 0b5eb42..825a8c7 100644
--- a/ext/fox16/markfuncs.cpp
+++ b/ext/fox16/markfuncs.cpp
@@ -81,8 +81,8 @@ void FXRbIconSource::markfunc(FXIconSource* iconSource){
 void FXRbTranslator::markfunc(FXTranslator* translator){
   FXRbObject::markfunc(translator);
   if(translator){
-    FXRbGcMark(translator->getApp());
-    FXRbGcMark(translator->getTextCodec());
+    FXRbGcMark(translator->FXTranslator::getApp());
+    FXRbGcMark(translator->FXTranslator::getTextCodec());
     }
   }
 
@@ -124,8 +124,8 @@ void FXRbKnob::markfunc(FXKnob* self){
 void FXRbLabel::markfunc(FXLabel* self){
   FXRbFrame::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
-    FXRbGcMark(self->getIcon());
+    FXRbGcMark(self->FXLabel::getFont());
+    FXRbGcMark(self->FXLabel::getIcon());
     }
   }
 
@@ -145,21 +145,22 @@ void FXRbDockHandler::markfunc(FXDockHandler *dockhandler){
 void FXRbDockTitle::markfunc(FXDockTitle *self){
   FXRbDockHandler::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXDockTitle::getFont());
     }
   }
 
 void FXRbDrawable::markfunc(FXDrawable* drawable){
   FXRbId::markfunc(drawable);
-  if(drawable) FXRbGcMark(drawable->getVisual());
+  if(drawable) FXRbGcMark(drawable->FXDrawable::getVisual());
   }
 
 
 void FXRbId::markfunc(FXId* self){
   FXRbObject::markfunc(self);
   if(self){
-    FXRbGcMark(self->getApp());
-    if(self->getUserData()) MARK(self->getUserData());
+    FXRbGcMark(self->FXId::getApp());
+    if(void *d=self->FXId::getUserData())
+      MARK(d);
     }
   }
 
@@ -185,23 +186,23 @@ void FXRbChoiceBox::markfunc(FXChoiceBox* box){
 void FXRbWindow::markfunc(FXWindow* self){
   FXRbDrawable::markfunc(self);
   if(self){
-    FXRbGcMark(self->getParent());
-    FXRbGcMark(self->getOwner());
-    FXRbGcMark(self->getShell());
-    FXRbGcMark(self->getRoot());
-    // FXRbGcMark(self->getNext());
-    // FXRbGcMark(self->getPrev());
-    FXRbGcMark(self->getFocus());
-    FXRbGcMark(self->getTarget());
-    FXRbGcMark(self->getAccelTable());
-    FXRbGcMark(self->getDefaultCursor());
-    FXRbGcMark(self->getDragCursor());
+    FXRbGcMark(self->FXWindow::getParent());
+    FXRbGcMark(self->FXWindow::getOwner());
+    FXRbGcMark(self->FXWindow::getShell());
+    FXRbGcMark(self->FXWindow::getRoot());
+    // FXRbGcMark(self->FXWindow::getNext());
+    // FXRbGcMark(self->FXWindow::getPrev());
+    FXRbGcMark(self->FXWindow::getFocus());
+    FXRbGcMark(self->FXWindow::getTarget());
+    FXRbGcMark(self->FXWindow::getAccelTable());
+    FXRbGcMark(self->FXWindow::getDefaultCursor());
+    FXRbGcMark(self->FXWindow::getDragCursor());
 
     // Mark child windows
-    register FXWindow* child=self->getFirst();
+    register FXWindow* child=self->FXWindow::getFirst();
     while(child!=NULL){
       FXRbGcMark(child);
-      child=child->getNext();
+      child=child->FXWindow::getNext();
       }
     }
   }
@@ -215,8 +216,8 @@ void FXRbDialogBox::markfunc(FXDialogBox* dlg){
 void FXRbTopWindow::markfunc(FXTopWindow* top){
   FXRbShell::markfunc(top);
   if(top){
-    FXRbGcMark(top->getIcon());
-    FXRbGcMark(top->getMiniIcon());
+    FXRbGcMark(top->FXTopWindow::getIcon());
+    FXRbGcMark(top->FXTopWindow::getMiniIcon());
     }
   }
 
@@ -266,7 +267,7 @@ void FXRbVerticalFrame::markfunc(FXVerticalFrame* self){
 void FXRbGroupBox::markfunc(FXGroupBox* self){
   FXRbPacker::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXGroupBox::getFont());
     }
   }
 
@@ -279,10 +280,10 @@ void FXRbColorWell::markfunc(FXColorWell* cw){
 void FXRbComboBox::markfunc(FXComboBox* self){
   FXRbPacker::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXComboBox::getFont());
     for(FXint i=0; i<self->getNumItems(); i++){
-      if(self->getItemData(i))
-        MARK(self->getItemData(i));
+      if(void *d=self->FXComboBox::getItemData(i))
+        MARK(d);
       }
     }
   }
@@ -302,42 +303,42 @@ void FXRbApp::markfunc(FXApp *self){
   FXRbObject::markfunc(self);
   if(self){
     // Visuals
-    FXRbGcMark(self->getMonoVisual());
-    FXRbGcMark(self->getDefaultVisual());
+    FXRbGcMark(self->FXApp::getMonoVisual());
+    FXRbGcMark(self->FXApp::getDefaultVisual());
 
     // Fonts
-    FXRbGcMark(self->getNormalFont());
+    FXRbGcMark(self->FXApp::getNormalFont());
 
     // Cursors
-    FXRbGcMark(self->getWaitCursor());
-    FXRbGcMark(self->getDefaultCursor(DEF_ARROW_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_RARROW_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_TEXT_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_HSPLIT_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_VSPLIT_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_XSPLIT_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_SWATCH_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_MOVE_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_DRAGH_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_DRAGV_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_DRAGTL_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_DRAGBR_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_DRAGTR_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_DRAGBL_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_DNDSTOP_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_DNDCOPY_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_DNDMOVE_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_DNDLINK_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_CROSSHAIR_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_CORNERNE_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_CORNERNW_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_CORNERSE_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_CORNERSW_CURSOR));
-    FXRbGcMark(self->getDefaultCursor(DEF_ROTATE_CURSOR));
+    FXRbGcMark(self->FXApp::getWaitCursor());
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_ARROW_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_RARROW_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_TEXT_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_HSPLIT_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_VSPLIT_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_XSPLIT_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_SWATCH_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_MOVE_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_DRAGH_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_DRAGV_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_DRAGTL_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_DRAGBR_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_DRAGTR_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_DRAGBL_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_DNDSTOP_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_DNDCOPY_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_DNDMOVE_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_DNDLINK_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_CROSSHAIR_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_CORNERNE_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_CORNERNW_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_CORNERSE_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_CORNERSW_CURSOR));
+    FXRbGcMark(self->FXApp::getDefaultCursor(DEF_ROTATE_CURSOR));
 
     // Other windows
-    FXRbGcMark(self->getFocusWindow());
-    FXRbGcMark(self->getCursorWindow());
+    FXRbGcMark(self->FXApp::getFocusWindow());
+    FXRbGcMark(self->FXApp::getCursorWindow());
 
     /**
      * Root window is a special case; popups (like FXTooltip) can be created
@@ -346,13 +347,13 @@ void FXRbApp::markfunc(FXApp *self){
      * So unless we invoke FXRbRootWindow's mark function here, unowned windows
      * like tooltips may get garbage-collected prematurely.
      */
-    if(self->getRootWindow()){
-      FXRbGcMark(self->getRootWindow());
-      FXRbRootWindow::markfunc(self->getRootWindow());
+    if(self->FXApp::getRootWindow()){
+      FXRbGcMark(self->FXApp::getRootWindow());
+      FXRbRootWindow::markfunc(self->FXApp::getRootWindow());
       }
 
     // Registry
-    FXRbGcMark(&(self->reg()));
+    FXRbGcMark(&(self->FXApp::reg()));
 
     // Timers, chores and signals are recycled and should never be destroyed
     }
@@ -377,19 +378,19 @@ void FXRbMainWindow::markfunc(FXMainWindow* obj){
 void FXRbTreeItem::markfunc(FXTreeItem* self){
   FXRbObject::markfunc(self);
   if(self){
-    FXRbGcMark(self->getParent());
-    FXRbGcMark(self->getNext());
-    FXRbGcMark(self->getPrev());
-    for(FXTreeItem* item=self->getFirst(); item; item=item->getNext()){
+    FXRbGcMark(self->FXTreeItem::getParent());
+    FXRbGcMark(self->FXTreeItem::getNext());
+    FXRbGcMark(self->FXTreeItem::getPrev());
+    for(FXTreeItem* item=self->FXTreeItem::getFirst(); item; item=item->FXTreeItem::getNext()){
       FXRbGcMark(item);
       FXRbTreeItem::markfunc(item);
       }
-    FXRbGcMark(self->getBelow());
-    FXRbGcMark(self->getAbove());
-    FXRbGcMark(self->getOpenIcon());
-    FXRbGcMark(self->getClosedIcon());
-    if(self->getData())
-      MARK(self->getData());
+    FXRbGcMark(self->FXTreeItem::getBelow());
+    FXRbGcMark(self->FXTreeItem::getAbove());
+    FXRbGcMark(self->FXTreeItem::getOpenIcon());
+    FXRbGcMark(self->FXTreeItem::getClosedIcon());
+    if(void *d=self->FXTreeItem::getData())
+      MARK(d);
     }
   }
 
@@ -411,7 +412,7 @@ void FXRbTreeItem::freefunc(FXTreeItem* self){
             treeListBox->removeItem(self);
             }
           }
-	}
+        }
       }
     FXRbUnregisterRubyObj(self);
     }
@@ -421,11 +422,11 @@ void FXRbTreeItem::freefunc(FXTreeItem* self){
 void FXRbTreeList::markfunc(FXTreeList* self){
   FXRbScrollArea::markfunc(self);
   if(self){
-    for(FXTreeItem* item=self->getFirstItem(); item; item=item->getNext()){
+    for(FXTreeItem* item=self->FXTreeList::getFirstItem(); item; item=item->FXTreeItem::getNext()){
       FXRbGcMark(item);
       FXRbTreeItem::markfunc(item);
       }
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXTreeList::getFont());
     }
   }
 
@@ -433,19 +434,19 @@ void FXRbTreeList::markfunc(FXTreeList* self){
 void FXRbFoldingItem::markfunc(FXFoldingItem* self){
   FXRbObject::markfunc(self);
   if(self){
-    FXRbGcMark(self->getParent());
-    FXRbGcMark(self->getNext());
-    FXRbGcMark(self->getPrev());
-    for(FXFoldingItem* item=self->getFirst(); item; item=item->getNext()){
+    FXRbGcMark(self->FXFoldingItem::getParent());
+    FXRbGcMark(self->FXFoldingItem::getNext());
+    FXRbGcMark(self->FXFoldingItem::getPrev());
+    for(FXFoldingItem* item=self->FXFoldingItem::getFirst(); item; item=item->FXFoldingItem::getNext()){
       FXRbGcMark(item);
       FXRbFoldingItem::markfunc(item);
       }
-    FXRbGcMark(self->getBelow());
-    FXRbGcMark(self->getAbove());
-    FXRbGcMark(self->getOpenIcon());
-    FXRbGcMark(self->getClosedIcon());
-    if(self->getData())
-      MARK(self->getData());
+    FXRbGcMark(self->FXFoldingItem::getBelow());
+    FXRbGcMark(self->FXFoldingItem::getAbove());
+    FXRbGcMark(self->FXFoldingItem::getOpenIcon());
+    FXRbGcMark(self->FXFoldingItem::getClosedIcon());
+    if(void *d=self->FXFoldingItem::getData())
+      MARK(d);
     }
   }
 
@@ -458,11 +459,11 @@ void FXRbFoldingItem::freefunc(FXFoldingItem* self){
 void FXRbFoldingList::markfunc(FXFoldingList* self){
   FXRbScrollArea::markfunc(self);
   if(self){
-    for(FXFoldingItem* item=self->getFirstItem(); item; item=item->getNext()){
+    for(FXFoldingItem* item=self->FXFoldingList::getFirstItem(); item; item=item->FXFoldingItem::getNext()){
       FXRbGcMark(item);
       FXRbFoldingItem::markfunc(item);
       }
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXFoldingList::getFont());
     }
   }
 
@@ -470,9 +471,9 @@ void FXRbFoldingList::markfunc(FXFoldingList* self){
 void FXRbListItem::markfunc(FXListItem* self){
   FXRbObject::markfunc(self);
   if(self){
-    FXRbGcMark(self->getIcon());
-    if(self->getData())
-      MARK(self->getData());
+    FXRbGcMark(self->FXListItem::getIcon());
+    if(void *d=self->FXListItem::getData())
+      MARK(d);
     }
   }
 
@@ -495,14 +496,12 @@ void FXRbColorItem::freefunc(FXColorItem* self){
 void FXRbList::markfunc(FXList* self){
   FXRbScrollArea::markfunc(self);
   if(self){
-    for(FXint i=0;i<self->getNumItems();i++){
-      FXListItem* item=self->getItem(i);
+    for(FXint i=0;i<self->FXList::getNumItems();i++){
+      FXListItem* item=self->FXList::getItem(i);
       FXRbGcMark(item);
       FXRbListItem::markfunc(item);
-      if(self->getItemData(i))
-        MARK(self->getItemData(i));
       }
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXList::getFont());
     }
   }
 
@@ -515,9 +514,9 @@ void FXRbColorList::markfunc(FXColorList* self){
 void FXRbTableItem::markfunc(FXTableItem* self){
   FXRbObject::markfunc(self);
   if(self){
-    FXRbGcMark(self->getIcon());
-    if(self->getData())
-      MARK(self->getData());
+    FXRbGcMark(self->FXTableItem::getIcon());
+    if(void* d=self->FXTableItem::getData())
+      MARK(d);
     }
   }
 
@@ -531,16 +530,13 @@ void FXRbTable::markfunc(FXTable* self){
   register FXTableItem* item;
   FXRbScrollArea::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
-    FXRbGcMark(self->getRowHeaderFont());
-    FXRbGcMark(self->getColumnHeaderFont());
-    for(FXint row=0;row<self->getNumRows();row++){
-      for(FXint col=0;col<self->getNumColumns();col++){
-        item=self->getItem(row,col);
+    FXRbGcMark(self->FXTable::getFont());
+    FXRbGcMark(self->FXTable::getRowHeaderFont());
+    FXRbGcMark(self->FXTable::getColumnHeaderFont());
+    for(FXint row=0;row<self->FXTable::getNumRows();row++){
+      for(FXint col=0;col<self->FXTable::getNumColumns();col++){
+        item=self->FXTable::getItem(row,col);
         FXRbGcMark(item);
-        FXRbGcMark(self->getItemIcon(row,col));
-        if(self->getItemData(row,col))
-          MARK(self->getItemData(row,col));
         }
       }
     }
@@ -550,9 +546,9 @@ void FXRbTable::markfunc(FXTable* self){
 void FXRbHeaderItem::markfunc(FXHeaderItem* self){
   FXRbObject::markfunc(self);
   if(self){
-    FXRbGcMark(self->getIcon());
-    if(self->getData())
-      MARK(self->getData());
+    FXRbGcMark(self->FXHeaderItem::getIcon());
+    if(void* d=self->FXHeaderItem::getData())
+      MARK(d);
     }
   }
 
@@ -565,14 +561,12 @@ void FXRbHeaderItem::freefunc(FXHeaderItem* self){
 void FXRbHeader::markfunc(FXHeader* self){
   FXRbFrame::markfunc(self);
   if(self){
-    for(FXint i=0;i<self->getNumItems();i++){
-      FXHeaderItem* item=self->getItem(i);
+    for(FXint i=0;i<self->FXHeader::getNumItems();i++){
+      FXHeaderItem* item=self->FXHeader::getItem(i);
       FXRbGcMark(item);
       FXRbHeaderItem::markfunc(item);
-      if(item->getData())
-        MARK(item->getData());
       }
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXHeader::getFont());
     }
   }
 
@@ -580,10 +574,10 @@ void FXRbHeader::markfunc(FXHeader* self){
 void FXRbIconItem::markfunc(FXIconItem* self){
   FXRbObject::markfunc(self);
   if(self){
-    FXRbGcMark(self->getBigIcon());
-    FXRbGcMark(self->getMiniIcon());
-    if(self->getData())
-      MARK(self->getData());
+    FXRbGcMark(self->FXIconItem::getBigIcon());
+    FXRbGcMark(self->FXIconItem::getMiniIcon());
+    if(void *d=self->FXIconItem::getData())
+      MARK(d);
     }
   }
 
@@ -596,15 +590,13 @@ void FXRbIconItem::freefunc(FXIconItem* self){
 void FXRbIconList::markfunc(FXIconList* self){
   FXRbScrollArea::markfunc(self);
   if(self){
-    FXRbGcMark(self->getHeader());
-    for(FXint i=0;i<self->getNumItems();i++){
-      FXIconItem* item=self->getItem(i);
+    FXRbGcMark(self->FXIconList::getHeader());
+    for(FXint i=0;i<self->FXIconList::getNumItems();i++){
+      FXIconItem* item=self->FXIconList::getItem(i);
       FXRbGcMark(item);
       FXRbIconItem::markfunc(item);
-      if(self->getItemData(i))
-        MARK(self->getItemData(i));
       }
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXIconList::getFont());
     }
   }
 
@@ -612,7 +604,7 @@ void FXRbIconList::markfunc(FXIconList* self){
 void FXRbDelegator::markfunc(FXDelegator* self){
   FXRbObject::markfunc(self);
   if(self){
-    FXRbGcMark(self->getDelegate());
+    FXRbGcMark(self->FXDelegator::getDelegate());
     }
   }
 
@@ -645,7 +637,7 @@ void FXRbStringDict::markfunc(FXStringDict* self){
 void FXRbRecentFiles::markfunc(FXRecentFiles* self){
   FXRbObject::markfunc(self);
   if(self){
-    FXRbGcMark(self->getTarget());
+    FXRbGcMark(self->FXRecentFiles::getTarget());
     }
   }
 
@@ -653,8 +645,8 @@ void FXRbRecentFiles::markfunc(FXRecentFiles* self){
 void FXRbScrollArea::markfunc(FXScrollArea* self){
   FXRbComposite::markfunc(self);
   if(self){
-    FXRbGcMark(self->horizontalScrollBar());
-    FXRbGcMark(self->verticalScrollBar());
+    FXRbGcMark(self->FXScrollArea::horizontalScrollBar());
+    FXRbGcMark(self->FXScrollArea::verticalScrollBar());
     }
   }
 
@@ -667,7 +659,7 @@ void FXRbDocument::markfunc(FXDocument* self){
 void FXRbGLContext::markfunc(FXGLContext* self){
   FXRbObject::markfunc(self);
   if(self){
-    FXRbGcMark(self->getVisual());
+    FXRbGcMark(self->FXGLContext::getVisual());
     }
   }
 
@@ -690,15 +682,15 @@ void FXRbFont::freefunc(FXFont *self){
 void FXRbIconDict::markfunc(FXIconDict* self){
   FXRbDict::markfunc(self);
   if(self){
-    FXRbGcMark(self->getIconSource());
-    if(self->no()>0){
-      FXint pos=self->first();
-      FXint last=self->last();
+    FXRbGcMark(self->FXIconDict::getIconSource());
+    if(self->FXIconDict::no()>0){
+      FXint pos=self->FXIconDict::first();
+      FXint last=self->FXIconDict::last();
       while(pos<=last){
-        const FXchar* name=self->key(pos);
-        FXIcon* icon=self->find(name);
+        const FXchar* name=self->FXIconDict::key(pos);
+        FXIcon* icon=self->FXIconDict::find(name);
         FXRbGcMark(icon);
-        pos=self->next(pos);
+        pos=self->FXIconDict::next(pos);
         }
       }
     }
@@ -707,16 +699,16 @@ void FXRbIconDict::markfunc(FXIconDict* self){
 
 void FXRbFileDict::markfunc(FXFileDict* self){
   FXRbDict::markfunc(self);
-  FXRbGcMark(self->getSettings());
+  FXRbGcMark(self->FXFileDict::getSettings());
   if(self){
-    if(self->no()>0){
-      FXint pos=self->first();
-      FXint last=self->last();
+    if(self->FXFileDict::no()>0){
+      FXint pos=self->FXFileDict::first();
+      FXint last=self->FXFileDict::last();
       while(pos<=last){
-        const FXchar* key=self->key(pos);
-        FXFileAssoc* assoc=self->find(key);
+        const FXchar* key=self->FXFileDict::key(pos);
+        FXFileAssoc* assoc=self->FXFileDict::find(key);
         FXRbGcMark(assoc);
-        pos=self->next(pos);
+        pos=self->FXFileDict::next(pos);
         }
       }
     }
@@ -739,7 +731,7 @@ void FXRbDirItem::markfunc(FXDirItem* self){
   FXTRACE((100,"FXRbDirItem::markfunc() %p\n",self));
   FXRbTreeItem::markfunc(self);
   if(self){
-    FXRbGcMark(self->getAssoc());
+    FXRbGcMark(self->FXDirItem::getAssoc());
     }
   }
 
@@ -752,7 +744,7 @@ void FXRbDirList::markfunc(FXDirList* self){
   FXTRACE((100,"FXRbDirList::markfunc() %p\n",self));
   FXRbTreeList::markfunc(self);
   if(self){
-    FXRbGcMark(self->getAssociations());
+    FXRbGcMark(self->FXDirList::getAssociations());
     }
   }
 
@@ -761,10 +753,10 @@ void FXRb4Splitter::markfunc(FX4Splitter* self){
   FXTRACE((100,"FXRb4Splitter::markfunc() %p\n",self));
   FXRbComposite::markfunc(self);
   if(self){
-    FXRbGcMark(self->getTopLeft());
-    FXRbGcMark(self->getTopRight());
-    FXRbGcMark(self->getBottomLeft());
-    FXRbGcMark(self->getBottomRight());
+    FXRbGcMark(self->FX4Splitter::getTopLeft());
+    FXRbGcMark(self->FX4Splitter::getTopRight());
+    FXRbGcMark(self->FX4Splitter::getBottomLeft());
+    FXRbGcMark(self->FX4Splitter::getBottomRight());
     }
   }
 
@@ -773,7 +765,7 @@ void FXRbFileItem::markfunc(FXFileItem* self){
   FXTRACE((100,"FXRbFileItem::markfunc() %p\n",self));
   FXRbIconItem::markfunc(self);
   if(self){
-    FXRbGcMark(self->getAssoc());
+    FXRbGcMark(self->FXFileItem::getAssoc());
     }
   }
 
@@ -787,9 +779,9 @@ void FXRbFileList::markfunc(FXFileList* self){
   FXTRACE((100,"FXRbFileList::markfunc() %p\n",self));
   FXRbIconList::markfunc(self);
   if(self){
-    FXRbGcMark(self->getAssociations());
-    for(FXint i=0;i<self->getNumItems();i++){
-      FXFileAssoc* assoc=self->getItemAssoc(i);
+    FXRbGcMark(self->FXFileList::getAssociations());
+    for(FXint i=0;i<self->FXFileList::getNumItems();i++){
+      FXFileAssoc* assoc=self->FXFileList::getItemAssoc(i);
       FXRbGcMark(assoc);
       }
     }
@@ -812,8 +804,8 @@ void FXRbDirSelector::markfunc(FXDirSelector* self){
   FXTRACE((100,"FXRbDirSelector::markfunc() %p\n",self));
   FXRbPacker::markfunc(self);
   if(self){
-    FXRbGcMark(self->acceptButton());
-    FXRbGcMark(self->cancelButton());
+    FXRbGcMark(self->FXDirSelector::acceptButton());
+    FXRbGcMark(self->FXDirSelector::cancelButton());
     }
   }
 
@@ -822,8 +814,8 @@ void FXRbFileSelector::markfunc(FXFileSelector* self){
   FXTRACE((100,"FXRbFileSelector::markfunc() %p\n",self));
   FXRbPacker::markfunc(self);
   if(self){
-    FXRbGcMark(self->acceptButton());
-    FXRbGcMark(self->cancelButton());
+    FXRbGcMark(self->FXFileSelector::acceptButton());
+    FXRbGcMark(self->FXFileSelector::cancelButton());
     }
   }
 
@@ -832,8 +824,8 @@ void FXRbFontSelector::markfunc(FXFontSelector* self){
   FXTRACE((100,"FXRbFontSelector::markfunc() %p\n",self));
   FXRbPacker::markfunc(self);
   if(self){
-    FXRbGcMark(self->acceptButton());
-    FXRbGcMark(self->cancelButton());
+    FXRbGcMark(self->FXFontSelector::acceptButton());
+    FXRbGcMark(self->FXFontSelector::cancelButton());
     }
   }
 
@@ -860,11 +852,11 @@ void FXRbListBox::markfunc(FXListBox* self){
   FXTRACE((100,"FXRbListBox::markfunc() %p\n",self));
   FXRbPacker::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
-    for(FXint i=0;i<self->getNumItems();i++){
-      FXRbGcMark(self->getItemIcon(i));
-      if(self->getItemData(i))
-        MARK(self->getItemData(i));
+    FXRbGcMark(self->FXListBox::getFont());
+    for(FXint i=0;i<self->FXListBox::getNumItems();i++){
+      FXRbGcMark(self->FXListBox::getItemIcon(i));
+      if(self->FXListBox::getItemData(i))
+        MARK(self->FXListBox::getItemData(i));
       }
     }
   }
@@ -874,8 +866,8 @@ void FXRbTreeListBox::markfunc(FXTreeListBox* self){
   FXTRACE((100,"FXRbTreeListBox::markfunc() %p\n",self));
   FXRbPacker::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
-    for(FXTreeItem* item=self->getFirstItem();item!=0;item=item->getNext()){
+    FXRbGcMark(self->FXTreeListBox::getFont());
+    for(FXTreeItem* item=self->FXTreeListBox::getFirstItem();item!=0;item=item->FXTreeItem::getNext()){
       FXRbGcMark(item);
       FXRbTreeItem::markfunc(item);
       }
@@ -887,7 +879,7 @@ void FXRbToolTip::markfunc(FXToolTip* self){
   FXTRACE((100,"FXRbToolTip::markfunc() %p\n",self));
   FXRbShell::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXToolTip::getFont());
     }
   }
 
@@ -938,7 +930,7 @@ void FXRbTextField::markfunc(FXTextField *self){
   FXTRACE((100,"FXRbTextField::markfunc() %p\n",self));
   FXRbFrame::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXTextField::getFont());
     }
   }
 
@@ -947,7 +939,7 @@ void FXRbMenuCascade::markfunc(FXMenuCascade *self){
   FXTRACE((100,"FXRbMenuCascade::markfunc() %p\n",self));
   FXRbMenuCaption::markfunc(self);
   if(self){
-    FXRbGcMark(self->getMenu());
+    FXRbGcMark(self->FXMenuCascade::getMenu());
     }
   }
 
@@ -979,7 +971,7 @@ void FXRbProgressBar::markfunc(FXProgressBar *self){
   FXTRACE((100,"FXRbProgressBar::markfunc() %p\n",self));
   FXRbFrame::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXProgressBar::getFont());
     }
   }
 
@@ -1000,7 +992,7 @@ void FXRbSpinner::markfunc(FXSpinner *self){
   FXTRACE((100,"FXRbSpinner::markfunc() %p\n",self));
   FXRbPacker::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXSpinner::getFont());
     }
   }
 
@@ -1009,7 +1001,7 @@ void FXRbRealSpinner::markfunc(FXRealSpinner *self){
   FXTRACE((100,"FXRbRealSpinner::markfunc() %p\n",self));
   FXRbPacker::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXRealSpinner::getFont());
     }
   }
 
@@ -1054,7 +1046,7 @@ void FXRbMenuButton::markfunc(FXMenuButton *self){
   FXTRACE((100,"FXRbMenuButton::markfunc() %p\n",self));
   FXRbLabel::markfunc(self);
   if(self){
-    FXRbGcMark(self->getMenu());
+    FXRbGcMark(self->FXMenuButton::getMenu());
     }
   }
 
@@ -1157,8 +1149,8 @@ void FXRbGLViewer::markfunc(FXGLViewer *self){
   FXTRACE((100,"FXRbGLViewer::markfunc() %p\n",self));
   FXRbGLCanvas::markfunc(self);
   if(self){
-    FXRbGcMark(self->getScene());
-    FXRbGcMark(self->getSelection());
+    FXRbGcMark(self->FXGLViewer::getScene());
+    FXRbGcMark(self->FXGLViewer::getSelection());
     }
   }
 
@@ -1208,8 +1200,8 @@ void FXRbStatusBar::markfunc(FXStatusBar *self){
   FXTRACE((100,"FXRbStatusBar::markfunc() %p\n",self));
   FXRbHorizontalFrame::markfunc(self);
   if(self){
-    FXRbGcMark(self->getStatusLine());
-    FXRbGcMark(self->getDragCorner());
+    FXRbGcMark(self->FXStatusBar::getStatusLine());
+    FXRbGcMark(self->FXStatusBar::getDragCorner());
     }
   }
 
@@ -1218,10 +1210,10 @@ void FXRbMDIChild::markfunc(FXMDIChild *self){
   FXTRACE((100,"FXRbMDIChild::markfunc() %p\n",self));
   FXRbComposite::markfunc(self);
   if(self){
-    FXRbGcMark(self->contentWindow());
-    FXRbGcMark(self->getIcon());
-    FXRbGcMark(self->getMenu());
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXMDIChild::contentWindow());
+    FXRbGcMark(self->FXMDIChild::getIcon());
+    FXRbGcMark(self->FXMDIChild::getMenu());
+    FXRbGcMark(self->FXMDIChild::getFont());
     }
   }
 
@@ -1253,7 +1245,7 @@ void FXRbToggleButton::markfunc(FXToggleButton *self){
   FXTRACE((100,"FXRbToggleButton::markfunc() %p\n",self));
   FXRbLabel::markfunc(self);
   if(self){
-    FXRbGcMark(self->getAltIcon());
+    FXRbGcMark(self->FXToggleButton::getAltIcon());
     }
   }
 
@@ -1262,7 +1254,7 @@ void FXRbTriStateButton::markfunc(FXTriStateButton *self){
   FXTRACE((100,"FXRbTriStateButton::markfunc() %p\n",self));
   FXRbToggleButton::markfunc(self);
   if(self){
-    FXRbGcMark(self->getMaybeIcon());
+    FXRbGcMark(self->FXTriStateButton::getMaybeIcon());
     }
   }
 
@@ -1271,7 +1263,7 @@ void FXRbPopup::markfunc(FXPopup *self){
   FXTRACE((100,"FXRbPopup::markfunc() %p\n",self));
   FXRbShell::markfunc(self);
   if(self){
-    FXRbGcMark(self->getGrabOwner());
+    FXRbGcMark(self->FXPopup::getGrabOwner());
     }
   }
 
@@ -1280,8 +1272,8 @@ void FXRbOptionMenu::markfunc(FXOptionMenu *self){
   FXTRACE((100,"FXRbOptionMenu::markfunc() %p\n",self));
   FXRbLabel::markfunc(self);
   if(self){
-    FXRbGcMark(self->getCurrent());
-    FXRbGcMark(self->getMenu());
+    FXRbGcMark(self->FXOptionMenu::getCurrent());
+    FXRbGcMark(self->FXOptionMenu::getMenu());
     }
   }
 
@@ -1296,8 +1288,8 @@ void FXRbToolBar::markfunc(FXToolBar *self){
   FXTRACE((100,"FXRbToolBar::markfunc() %p\n",self));
   FXRbPacker::markfunc(self);
   if(self){
-    FXRbGcMark(self->getDryDock());
-    FXRbGcMark(self->getWetDock());
+    FXRbGcMark(self->FXToolBar::getDryDock());
+    FXRbGcMark(self->FXToolBar::getWetDock());
     }
   }
 
@@ -1329,7 +1321,7 @@ void FXRbScrollWindow::markfunc(FXScrollWindow *self){
   FXTRACE((100,"FXRbScrollWindow::markfunc() %p\n",self));
   FXRbScrollArea::markfunc(self);
   if(self){
-    FXRbGcMark(self->contentWindow());
+    FXRbGcMark(self->FXScrollWindow::contentWindow());
     }
   }
 
@@ -1338,7 +1330,7 @@ void FXRbText::markfunc(FXText *self){
   FXTRACE((100,"FXRbText::markfunc() %p\n",self));
   FXRbScrollArea::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXText::getFont());
     }
   }
 
@@ -1352,7 +1344,7 @@ void FXRbSplashWindow::markfunc(FXSplashWindow *self){
   FXTRACE((100,"FXRbSplashWindow::markfunc() %p\n",self));
   FXRbTopWindow::markfunc(self);
   if(self){
-    FXRbGcMark(self->getIcon());
+    FXRbGcMark(self->FXSplashWindow::getIcon());
     }
   }
 
@@ -1372,7 +1364,7 @@ void FXRbMenuTitle::markfunc(FXMenuTitle *self){
   FXTRACE((100,"FXRbMenuTitle::markfunc() %p\n",self));
   FXRbMenuCaption::markfunc(self);
   if(self){
-    FXRbGcMark(self->getMenu());
+    FXRbGcMark(self->FXMenuTitle::getMenu());
     }
   }
 
@@ -1390,7 +1382,7 @@ void FXRbBitmapView::markfunc(FXBitmapView *self){
 void FXRbImageView::markfunc(FXImageView *self){
   FXRbScrollArea::markfunc(self);
   if(self){
-    FXRbGcMark(self->getImage());
+    FXRbGcMark(self->FXImageView::getImage());
     }
   }
 
@@ -1398,8 +1390,8 @@ void FXRbImageView::markfunc(FXImageView *self){
 void FXRbShutterItem::markfunc(FXShutterItem *self){
   FXRbVerticalFrame::markfunc(self);
   if(self){
-    FXRbGcMark(self->getButton());
-    FXRbGcMark(self->getContent());
+    FXRbGcMark(self->FXShutterItem::getButton());
+    FXRbGcMark(self->FXShutterItem::getContent());
     }
   }
 
@@ -1414,8 +1406,8 @@ void FXRbMenuCaption::markfunc(FXMenuCaption *self){
   FXTRACE((100,"FXRbMenuCaption::markfunc() %p\n",self));
   FXRbWindow::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
-    FXRbGcMark(self->getIcon());
+    FXRbGcMark(self->FXMenuCaption::getFont());
+    FXRbGcMark(self->FXMenuCaption::getIcon());
     }
   }
 
@@ -1430,7 +1422,7 @@ void FXRbStatusLine::markfunc(FXStatusLine *self){
   FXTRACE((100,"FXRbStatusLine::markfunc() %p\n",self));
   FXRbFrame::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXStatusLine::getFont());
     }
   }
 
@@ -1480,7 +1472,7 @@ void FXRbScrollBar::markfunc(FXScrollBar *self){
 void FXRbStream::markfunc(FXStream *self){
   FXTRACE((100,"FXRbStream::markfunc() %p\n",self));
   if(self){
-    FXRbGcMark((void*)self->container());
+    FXRbGcMark((void*)self->FXStream::container());
     }
   }
 
@@ -1572,7 +1564,7 @@ void FXRbBitmapFrame::markfunc(FXBitmapFrame* self){
   FXTRACE((100,"start FXRbBitmapFrame::markfunc(%p)\n",self));
   FXRbFrame::markfunc(self);
   if(self!=0){
-    FXRbGcMark(self->getBitmap());
+    FXRbGcMark(self->FXBitmapFrame::getBitmap());
     }
   FXTRACE((100,"end FXRbBitmapFrame::markfunc(%p)\n",self));
   }
@@ -1582,7 +1574,7 @@ void FXRbImageFrame::markfunc(FXImageFrame* self){
   FXTRACE((100,"start FXRbImageFrame::markfunc(%p)\n",self));
   FXRbFrame::markfunc(self);
   if(self!=0){
-    FXRbGcMark(self->getImage());
+    FXRbGcMark(self->FXImageFrame::getImage());
     }
   FXTRACE((100,"end FXRbImageFrame::markfunc(%p)\n",self));
   }
@@ -1607,12 +1599,12 @@ void FXRbWizard::markfunc(FXWizard* self){
   FXTRACE((100,"FXRbWizard::markfunc() %p\n",self));
   FXRbDialogBox::markfunc(self);
   if(self){
-    FXRbGcMark(self->advanceButton());
-    FXRbGcMark(self->retreatButton());
-    FXRbGcMark(self->finishButton());
-    FXRbGcMark(self->cancelButton());
-    FXRbGcMark(self->getContainer());
-    FXRbGcMark(self->getImage());
+    FXRbGcMark(self->FXWizard::advanceButton());
+    FXRbGcMark(self->FXWizard::retreatButton());
+    FXRbGcMark(self->FXWizard::finishButton());
+    FXRbGcMark(self->FXWizard::cancelButton());
+    FXRbGcMark(self->FXWizard::getContainer());
+    FXRbGcMark(self->FXWizard::getImage());
     }
   }
 
@@ -1621,7 +1613,7 @@ void FXRbRuler::markfunc(FXRuler* self){
   FXTRACE((100,"FXRbRuler::markfunc() %p\n",self));
   FXRbFrame::markfunc(self);
   if(self){
-    FXRbGcMark(self->getFont());
+    FXRbGcMark(self->FXRuler::getFont());
     }
   }
 
@@ -1630,10 +1622,10 @@ void FXRbRulerView::markfunc(FXRulerView* self){
   FXTRACE((100,"FXRbRulerView::markfunc() %p\n",self));
   FXRbScrollArea::markfunc(self);
   if(self){
-    FXRbGcMark(self->horizontalRuler());
-    FXRbGcMark(self->verticalRuler());
-    FXRbGcMark(self->getHRulerFont());
-    FXRbGcMark(self->getVRulerFont());
+    FXRbGcMark(self->FXRulerView::horizontalRuler());
+    FXRbGcMark(self->FXRulerView::verticalRuler());
+    FXRbGcMark(self->FXRulerView::getHRulerFont());
+    FXRbGcMark(self->FXRulerView::getVRulerFont());
     }
   }
 
-- 
GitLab