fxruby 1.6.22.pre2-x86-mingw32 → 1.6.22.pre3-x86-mingw32

data/ext/fox16/include/FXRuby.h

@@ -69,10 +69,12 @@ VALUE showHelper(VALUE self, int argc, VALUE *argv, TYPE *p, swig_type_info *typ
     }
   return Qnil;
   }
-    
+
 // Wrapper around SWIG_Ruby_NewPointerObj()
 VALUE FXRbNewPointerObj(void *ptr, swig_type_info *typeinfo);
 bool FXRbIsBorrowed(void* ptr);
+bool FXRbSetInGC(const void* ptr, bool enabled);
+bool FXRbIsInGC(const void* ptr);
 
 // Wrapper around SWIG_TypeQuery()
 swig_type_info *FXRbTypeQuery(const char *name);
@@ -235,7 +237,7 @@ inline VALUE to_ruby(FXStream& store){
 inline VALUE to_ruby(const FXPoint* point){
   return FXRbNewPointerObj(static_cast<void*>(const_cast<FXPoint*>(point)),FXRbTypeQuery("FXPoint *"));
   }
- 
+
 inline VALUE to_ruby(const FXSegment* segment){
   return FXRbNewPointerObj(static_cast<void*>(const_cast<FXSegment*>(segment)),FXRbTypeQuery("FXSegment *"));
   }
@@ -304,7 +306,7 @@ inline FXID int_to_fxid(VALUE value){
 #ifndef WIN32
   return static_cast<FXID>(NUM2UINT(value));
 #else
-  return reinterpret_cast<FXID>(NUM2ULONG(value)); 
+  return reinterpret_cast<FXID>(NUM2ULONG(value));
 #endif
   }
 
@@ -322,6 +324,7 @@ template<class TYPE>
 void FXRbCallVoidMethod(FXObject* recv,ID func, TYPE& arg){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
+  FXASSERT(!FXRbIsInGC(recv));
   rb_funcall(obj,func,1,to_ruby(arg));
   }
 
@@ -331,11 +334,12 @@ void FXRbCallVoidMethod(FXDC* recv,ID func,TYPE arg){
   FXASSERT(!NIL_P(obj));
   rb_funcall(obj,func,1,to_ruby(arg));
   }
- 
+
 template<class TYPE>
 void FXRbCallVoidMethod(const FXObject* recv, ID func, TYPE& arg){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
+  FXASSERT(!FXRbIsInGC(recv));
   rb_funcall(obj,func,1,to_ruby(arg));
   }
 

data/ext/fox16/librb.c

@@ -15,8 +15,8 @@
 #define SWIG_TypePrettyName  SWIG_Ruby_TypePrettyName
 #define SWIG_TypeQuery       SWIG_Ruby_TypeQuery
 #define SWIG_TypeClientData  SWIG_Ruby_TypeClientData
-#define SWIG_PackData        SWIG_Ruby_PackData 
-#define SWIG_UnpackData      SWIG_Ruby_UnpackData 
+#define SWIG_PackData        SWIG_Ruby_PackData
+#define SWIG_UnpackData      SWIG_Ruby_UnpackData
 
 /* Also rename all exported symbols from rubydef.swig */
 
@@ -55,7 +55,7 @@
  * Author : David Beazley (beazley@cs.uchicago.edu)
  *
  * Copyright (c) 1999-2000, The University of Chicago
- * 
+ *
  * This file may be freely redistributed without license or fee provided
  * this copyright message remains intact.
  ************************************************************************/
@@ -166,7 +166,7 @@ SWIG_TypeRegister(swig_type_info *ti) {
 }
 
 /* Check the typename */
-SWIGRUNTIME(swig_type_info *) 
+SWIGRUNTIME(swig_type_info *)
 SWIG_TypeCheck(char *c, swig_type_info *ty) {
   swig_type_info *s;
   if (!ty) return 0;        /* Void pointer */
@@ -192,14 +192,14 @@ SWIG_TypeCheck(char *c, swig_type_info *ty) {
 }
 
 /* Cast a pointer up an inheritance hierarchy */
-SWIGRUNTIME(void *) 
+SWIGRUNTIME(void *)
 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
   if ((!ty) || (!ty->converter)) return ptr;
   return (*ty->converter)(ptr);
 }
 
 /* Dynamic pointer casting. Down an inheritance hierarchy */
-SWIGRUNTIME(swig_type_info *) 
+SWIGRUNTIME(swig_type_info *)
 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
   swig_type_info *lastty = ty;
   if (!ty || !ty->dcast) return ty;
@@ -236,7 +236,7 @@ SWIG_TypePrettyName(const swig_type_info *type) {
     return type->name;
 }
 
-/* 
+/*
    Compare two type names skipping the space characters, therefore
    "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 
@@ -271,7 +271,7 @@ SWIG_TypeEquiv(const char *nb, const char *tb) {
   }
   return equiv;
 }
-  
+
 
 /* Search for a swig_type_info structure */
 SWIGRUNTIME(swig_type_info *)
@@ -405,7 +405,7 @@ SWIG_UnpackData(char *c, void *ptr, int sz) {
  * can be passed as an argument to API functions like Data_Wrap_Struct()
  * and Data_Make_Struct().
  */
- 
+
 #ifdef __cplusplus
 #  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
 #    define PROTECTFUNC(f) ((VALUE (*)()) f)
@@ -503,10 +503,10 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int own)
     swig_class *sklass;
     VALUE klass;
     VALUE obj;
-    
+
     if (!ptr)
 	return Qnil;
-    
+
     if (type->clientdata) {
       sklass = (swig_class *) type->clientdata;
       obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
@@ -554,7 +554,7 @@ SWIG_Ruby_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty, int flags)
   } else {
     Data_Get_Struct(obj, void, *ptr);
   }
-  
+
   /* Do type-checking if type info was provided */
   if (ty) {
     if (ty->clientdata) {

data/ext/fox16/list_wrap.cpp

@@ -701,7 +701,7 @@ FXint FXList_setItem__SWIG_1(FXList *self,FXint index,FXString const &text,FXIco
 
       // Do the deed
       FXint result=self->setItem(index,text,icon,ITEMDATA,notify);
-      
+
       // Now zero-out pointers held by still-alive Ruby objects
       FXRbUnregisterRubyObj(oldItem);
 

data/ext/fox16/make_impl.rb

@@ -11,7 +11,7 @@ class Processor
     @inside_class
   end
 
-  def getBaseClassName(klass) 
+  def getBaseClassName(klass)
     klass.sub(/FXRb/, "FX")
   end
 
@@ -55,7 +55,7 @@ class MyProcessor < Processor
     @classname = nil
     @baseclass = nil
   end
-  
+
   def start_class(classname, baseclass)
     @classname = classname
     @baseclass = baseclass
@@ -66,7 +66,7 @@ class MyProcessor < Processor
     @fcpp.printf("/* Start stub implementations for class %s */\n", classname)
     @finc.printf("/* Start stub declarations for class %s */\n", classname)
   end
-  
+
   def implement_overrides(filename)
     stubclass = filename.gsub('"', '').sub("FXRb", "FX")
     stubclass = stubclass.sub(/Virtuals\.h/, "").upcase
@@ -76,7 +76,7 @@ class MyProcessor < Processor
       @fcpp.printf("IMPLEMENT_%s_STUBS(%s,%s)\n", stubclass, @classname, @baseclass)
     end
   end
-  
+
   def implement_stubs(filename)
     stubclass = filename.gsub('"', '').sub("FXRb", "FX")
     stubclass = stubclass.sub(/Virtuals\.h/, "").upcase
@@ -95,7 +95,7 @@ class MyProcessor < Processor
       implement_stubs(incfile)
     end
   end
-  
+
   def end_class
     if @classname == "FXRbScintilla"
       @fcpp.puts "\n#endif"

data/ext/fox16/markfuncs.cpp

@@ -53,6 +53,11 @@ void FXRbObject::markfunc(FXObject* obj){
   FXTRACE((100,"%s::markfunc(%p)\n",obj?obj->getClassName():"FXRbObject",obj));
   }
 
+static void FXRbSetInGCRecursive(FXWindow *window, bool enabled){
+  FXRbSetInGC( window, true );
+  if(window->getParent()) FXRbSetInGCRecursive( window->getParent(), enabled );
+  }
+
 
 void FXRbObject::freefunc(FXObject* self){
   if(self!=0){
@@ -66,6 +71,17 @@ void FXRbObject::freefunc(FXObject* self){
     FXASSERT(classname!=0);
     FXASSERT(strlen(classname)>3);
     if(classname[0]=='F' && classname[1]=='X' && classname[2]=='R' && classname[3]=='b'){
+      // FXWindow destructor calls recalc() and changeFocus() of it's parent window.
+      // Since these methods are routed back to Ruby code, but calling Ruby code from
+      // GC isn't a good idea, we mark the parent window as "in_gc", so that it will
+      // ignore recalc() and changeFocus() calls completely.
+      // The parent window should also be scheduled to be free'd. In the other case,
+      // the child window would have been marked as used.
+      if(self->isMemberOf(FXMETACLASS(FXWindow))){
+        if(FXWindow *parent = dynamic_cast<FXWindow*>(self)->getParent()){
+          FXRbSetInGCRecursive( parent, true );
+          }
+        }
       delete self;
       }
     else{
@@ -77,12 +93,12 @@ void FXRbObject::freefunc(FXObject* self){
 void FXRbIconSource::markfunc(FXIconSource* iconSource){
   FXRbObject::markfunc(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 +140,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 +161,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 +202,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 +232,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 +283,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 +296,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,43 +319,43 @@ 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
      * without an "owner" by passing FXApp as the first argument to their
@@ -346,13 +363,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 +394,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 +428,7 @@ void FXRbTreeItem::freefunc(FXTreeItem* self){
             treeListBox->removeItem(self);
             }
           }
-	}
+        }
       }
     FXRbUnregisterRubyObj(self);
     }
@@ -421,11 +438,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 +450,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 +475,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 +487,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 +512,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());
     }
   }
 
@@ -511,13 +526,13 @@ void FXRbColorList::markfunc(FXColorList* self){
   FXRbList::markfunc(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 +546,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 +562,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 +577,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 +590,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 +606,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 +620,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 +653,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 +661,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 +675,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 +698,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 +715,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 +747,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 +760,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 +769,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 +781,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 +795,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 +820,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 +830,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 +840,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 +868,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 +882,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 +895,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 +946,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 +955,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 +987,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());
     }
   }
 
@@ -988,8 +996,8 @@ void FXRbSeparator::markfunc(FXSeparator* self){
   FXTRACE((100,"FXRbSeparator::markfunc() %p\n",self));
   FXRbFrame::markfunc(self);
  }
- 
- 
+
+
 void FXRbHorizontalSeparator::markfunc(FXHorizontalSeparator *self){
   FXTRACE((100,"FXRbHorizontalSeparator::markfunc() %p\n",self));
   FXRbSeparator::markfunc(self);
@@ -1000,7 +1008,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 +1017,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 +1062,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 +1165,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 +1216,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 +1226,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 +1261,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 +1270,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 +1279,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 +1288,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 +1304,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 +1337,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 +1346,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 +1360,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 +1380,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 +1398,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 +1406,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 +1422,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 +1438,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 +1488,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 +1580,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 +1590,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 +1615,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 +1629,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,14 +1638,14 @@ 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());
     }
   }
 
-  
+
 void FXRbPPMIcon::markfunc(FXPPMIcon* self){
   FXTRACE((100,"FXRbPPMIcon::markfunc() %p\n",self));
   FXRbIcon::markfunc(self);