fxruby 1.6.27-x64-mingw32

data/swig-interfaces/FXScintilla.i

@@ -0,0 +1,194 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001-2009 by Lyle Johnson. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+// Struct definition from Scintilla.h
+struct NotifyHeader {
+  %immutable;
+  unsigned int idFrom;
+  unsigned int code;
+  %mutable;
+};
+
+// Struct definition from Scintilla.h
+struct SCNotification {
+  %immutable;
+  struct NotifyHeader nmhdr;
+  int position;	// SCN_STYLENEEDED, SCN_MODIFIED, SCN_DWELLSTART, SCN_DWELLEND
+  int ch;		// SCN_CHARADDED, SCN_KEY
+  int modifiers;	// SCN_KEY
+  int modificationType;	// SCN_MODIFIED
+  %extend {
+    // Need to be careful about when this field's value is actually defined
+    VALUE text() const {
+      if (self->nmhdr.code==SCN_MODIFIED){
+        return (self->text) ? to_ruby(self->text,self->length) : Qnil;
+        }
+      else if (self->nmhdr.code==SCN_USERLISTSELECTION || self->nmhdr.code==SCN_URIDROPPED){
+        return (self->text) ? to_ruby(self->text) : Qnil;
+      } else {
+        return Qnil;
+      }
+    }
+  }
+  int length;		// SCN_MODIFIED
+  int linesAdded;	// SCN_MODIFIED
+  int message;	// SCN_MACRORECORD
+  int line;		// SCN_MODIFIED
+  int foldLevelNow;	// SCN_MODIFIED
+  int foldLevelPrev;	// SCN_MODIFIED
+  int margin;		// SCN_MARGINCLICK
+  int listType;	// SCN_USERLISTSELECTION
+  int x;			// SCN_DWELLSTART, SCN_DWELLEND
+  int y;		// SCN_DWELLSTART, SCN_DWELLEND
+  %mutable;
+  %extend {
+    VALUE wParam() const {
+      return INT2NUM(self->wParam);
+    }
+    VALUE lParam() const {
+      return INT2NUM(self->lParam);
+    }
+  }
+};
+
+struct TextRange {
+  %immutable;
+  char *lpstrText;
+  %mutable;
+  %extend {
+    // "Construct" a TextRange instance
+    TextRange(int start,int last,size_t size){
+      TextRange *tr=new TextRange;
+      tr->chrg.cpMin=start;
+      tr->chrg.cpMax=last;
+      FXMALLOC(&tr->lpstrText,char,size);
+      return tr;
+      }
+
+    // Destructor
+    ~TextRange(){
+      FXFREE(&self->lpstrText);
+      delete self;
+      }
+  }
+};
+
+
+class FXScintilla : public FXScrollArea {
+public:
+  enum{
+    ID_TICK,
+    };
+public:
+  long onScintillaCommand(FXObject*, FXSelector, void* PTR_IGNORE);
+  long onPaint(FXObject*, FXSelector, void* PTR_EVENT);
+  long onConfigure(FXObject*, FXSelector, void* PTR_EVENT);
+  long onTimeoutTicking(FXObject*, FXSelector, void* PTR_IGNORE);
+  long onFocusIn(FXObject*, FXSelector, void* PTR_EVENT);
+  long onFocusOut(FXObject*, FXSelector, void* PTR_EVENT);
+  long onMotion(FXObject*, FXSelector, void* PTR_EVENT);
+  long onLeftBtnPress(FXObject*, FXSelector, void* PTR_EVENT);
+  long onLeftBtnRelease(FXObject*, FXSelector, void* PTR_EVENT);
+  long onRightBtnPress(FXObject*, FXSelector, void* PTR_EVENT);
+  long onMiddleBtnPress(FXObject*, FXSelector, void* PTR_EVENT);
+  long onBeginDrag(FXObject*, FXSelector, void* PTR_EVENT);
+  long onDragged(FXObject*, FXSelector, void* PTR_EVENT);
+  long onEndDrag(FXObject*, FXSelector, void* PTR_EVENT);
+  long onDNDEnter(FXObject*, FXSelector, void* PTR_EVENT);
+  long onDNDLeave(FXObject*, FXSelector, void* PTR_EVENT);
+  long onDNDMotion(FXObject*, FXSelector, void* PTR_EVENT);
+  long onDNDDrop(FXObject*, FXSelector, void* PTR_EVENT);
+  long onDNDRequest(FXObject*, FXSelector, void* PTR_EVENT);
+  long onSelectionLost(FXObject*, FXSelector, void* PTR_EVENT);
+  long onSelectionRequest(FXObject*, FXSelector, void* PTR_EVENT);
+  long onClipboardLost(FXObject*, FXSelector, void* PTR_EVENT);
+  long onClipboardRequest(FXObject*, FXSelector, void* PTR_EVENT);
+  long onKeyPress(FXObject*, FXSelector, void* PTR_EVENT);
+public:
+  // Constructor
+  %extend {
+    FXScintilla(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbScintilla(p,tgt,sel,opts,x,y,w,h);
+      }
+    }
+
+  // Scintilla messaging
+  void setScintillaID(int id);
+
+  %extend {
+    VALUE sendMessage(unsigned int iMsg, VALUE wParam = Qnil, VALUE lParam = Qnil){
+      // Convert wParam argument
+      uptr_t wp;
+      switch(TYPE(wParam)){
+        case T_BIGNUM:
+        case T_FIXNUM:
+          wp=static_cast<uptr_t>(NUM2SIZET(wParam));
+          break;
+        case T_STRING:
+          wp=static_cast<uptr_t>(reinterpret_cast<FXuval>(RSTRING_PTR(wParam)));
+          break;
+        case T_TRUE:
+        case T_FALSE:
+          wp=(wParam==Qtrue) ? 1 : 0;
+          break;
+        default:
+          wp=0;
+          break;
+        }
+
+      // Convert lParam argument
+      sptr_t lp;
+      switch(TYPE(lParam)){
+        case T_BIGNUM:
+        case T_FIXNUM:
+          lp=static_cast<sptr_t>(NUM2SIZET(lParam));
+          break;
+        case T_STRING:
+          lp=static_cast<sptr_t>(reinterpret_cast<FXival>(RSTRING_PTR(lParam)));
+          break;
+        case T_TRUE:
+        case T_FALSE:
+          lp=(lParam==Qtrue) ? 1 : 0;
+          break;
+        case T_DATA:
+          lp=reinterpret_cast<sptr_t>(DATA_PTR(lParam));
+          break;
+        default:
+          lp=0;
+          break;
+        }
+      sptr_t result=self->sendMessage(iMsg,wp,lp);
+      return INT2NUM(result);
+      }
+  }
+
+  /// Destructor
+  virtual ~FXScintilla();
+  };
+
+
+DECLARE_FXOBJECT_VIRTUALS(FXScintilla)
+DECLARE_FXID_VIRTUALS(FXScintilla)
+DECLARE_FXDRAWABLE_VIRTUALS(FXScintilla)
+DECLARE_FXWINDOW_VIRTUALS(FXScintilla)
+DECLARE_FXSCROLLAREA_VIRTUALS(FXScintilla)
+

data/swig-interfaces/FXScrollArea.i

@@ -0,0 +1,211 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001-2009 by Lyle Johnson. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+/// ScrollBar options
+enum {
+  SCROLLERS_NORMAL     = 0,                                 /// Show the scrollbars when needed
+  HSCROLLER_ALWAYS     = 0x00008000,                        /// Always show horizontal scrollers
+  HSCROLLER_NEVER      = 0x00010000,                        /// Never show horizontal scrollers
+  VSCROLLER_ALWAYS     = 0x00020000,                        /// Always show vertical scrollers
+  VSCROLLER_NEVER      = 0x00040000,                        /// Never show vertical scrollers
+  HSCROLLING_ON        = 0,                                 /// Horizontal scrolling turned on (default)
+  HSCROLLING_OFF       = HSCROLLER_NEVER|HSCROLLER_ALWAYS,  /// Horizontal scrolling turned off
+  VSCROLLING_ON        = 0,                                 /// Vertical scrolling turned on (default)
+  VSCROLLING_OFF       = VSCROLLER_NEVER|VSCROLLER_ALWAYS,  /// Vertical scrolling turned off
+  SCROLLERS_TRACK      = 0,                                 /// Scrollers track continuously for smooth scrolling
+  SCROLLERS_DONT_TRACK = 0x00080000                         /// Scrollers don't track continuously
+  };
+
+
+class FXScrollBar;
+class FXScrollCorner;
+
+
+/**
+* The scroll area widget manages a content area and a viewport
+* area through which the content is viewed.  When the content area
+* becomes larger than the viewport area, scrollbars are placed to
+* permit viewing of the entire content by scrolling the content.
+* Depending on the mode, scrollbars may be displayed on an as-needed
+* basis, always, or never.
+* Normally, the scroll area's size and the content's size are independent;
+* however, it is possible to disable scrolling in the horizontal
+* (vertical) direction.  In this case, the content width (height)
+* will influence the width (height) of the scroll area widget.
+* For content which is time-consuming to repaint, continuous
+* scrolling may be turned off.
+*/
+class FXScrollArea : public FXComposite {
+protected:
+  FXScrollBar    *horizontal;   // Horizontal scroll bar
+  FXScrollBar    *vertical;     // Vertical scroll bar
+  FXScrollCorner *corner;       // Scroll corner
+  FXint           viewport_w;   // Viewport width
+  FXint           viewport_h;   // Viewport height
+  FXint           pos_x;        // X scroll position (pos_x<=0)
+  FXint           pos_y;        // Y scroll position (pos_y<=0)
+protected:
+  FXScrollArea();
+  FXbool startAutoScroll(FXEvent* event,FXbool onlywheninside=FALSE);
+  void stopAutoScroll();
+  FXScrollArea(FXComposite* p,FXuint opts,FXint x,FXint y,FXint w,FXint h);
+  virtual void moveContents(FXint x,FXint y);
+public:
+  long onHMouseWheel(FXObject*,FXSelector,void* PTR_EVENT);
+  long onVMouseWheel(FXObject*,FXSelector,void* PTR_EVENT);
+  long onHScrollerChanged(FXObject*,FXSelector,void* PTR_INT);
+  long onVScrollerChanged(FXObject*,FXSelector,void* PTR_INT);
+  long onHScrollerDragged(FXObject*,FXSelector,void* PTR_INT);
+  long onVScrollerDragged(FXObject*,FXSelector,void* PTR_INT);
+  long onAutoScroll(FXObject*,FXSelector,void* PTR_IGNORE);
+public:
+  %extend {
+    /// Constructor
+    FXScrollArea(FXComposite* p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbScrollArea(p,opts,x,y,w,h);
+      }
+    }
+
+  /// Change scroll style
+  void setScrollStyle(FXuint style);
+
+  /// Return scroll style
+  FXuint getScrollStyle() const;
+
+  /// Return TRUE if horizontally scrollable
+  FXbool isHorizontalScrollable() const;
+
+  /// Return TRUE if vertically scrollable
+  FXbool isVerticalScrollable() const;
+
+  /// Return a pointer to the horizontal scrollbar
+  FXScrollBar* horizontalScrollBar() const;
+
+  /// Return a pointer to the vertical scrollbar
+  FXScrollBar* verticalScrollBar() const;
+
+  /// Return the current x-position
+  FXint getXPosition() const;
+
+  /// Return the current y-position
+  FXint getYPosition() const;
+
+  /// Set the current position
+  void setPosition(FXint x,FXint y);
+
+#ifdef SWIGPYTHON
+  %extend {
+    PyObject* getPosition() const {
+      FXint x, y;
+      self->getPosition(x, y);
+      FXbool doSave = FXPyRestoreThread();
+      PyObject* tuple = PyTuple_New(2);
+      if (tuple) {
+	PyObject *obj1 = PyInt_FromLong(x);
+	if (!obj1 || PyTuple_SetItem(tuple, 0, obj1) < 0) {
+	  Py_DECREF(tuple);
+          FXPySaveThread(doSave);
+	  return NULL;
+	}
+	PyObject *obj2 = PyInt_FromLong(y);
+	if (!obj2 || PyTuple_SetItem(tuple, 1, obj2) < 0) {
+	  Py_DECREF(tuple);
+          FXPySaveThread(doSave);
+	  return NULL;
+	}
+      }
+      FXPySaveThread(doSave);
+      return tuple;
+    }
+  }
+#endif
+
+  /// Destructor
+  virtual ~FXScrollArea();
+  };
+
+
+DECLARE_FXOBJECT_VIRTUALS(FXScrollArea)
+DECLARE_FXID_VIRTUALS(FXScrollArea)
+DECLARE_FXDRAWABLE_VIRTUALS(FXScrollArea)
+DECLARE_FXWINDOW_VIRTUALS(FXScrollArea)
+DECLARE_FXSCROLLAREA_VIRTUALS(FXScrollArea)
+
+%{
+static swig_type_info *FXScrollArea_dynamic_cast(void **ptr) {
+    FXScrollArea **ppScrollArea = reinterpret_cast<FXScrollArea **>(ptr);
+    FXBitmapView *pBitmapView=dynamic_cast<FXBitmapView*>(*ppScrollArea);
+    if(pBitmapView){
+      *ptr=reinterpret_cast<void*>(pBitmapView);
+      return SWIG_TypeQuery("FXBitmapView *");
+      }
+    FXFoldingList *pFoldingList=dynamic_cast<FXFoldingList*>(*ppScrollArea);
+    if(pFoldingList){
+      *ptr=reinterpret_cast<void*>(pFoldingList);
+      return SWIG_TypeQuery("FXFoldingList *");
+      }
+    FXIconList *pIconList=dynamic_cast<FXIconList*>(*ppScrollArea);
+    if(pIconList){
+      *ptr=reinterpret_cast<void*>(pIconList);
+      return SWIG_TypeQuery("FXIconList *");
+      }
+    FXImageView *pImageView=dynamic_cast<FXImageView*>(*ppScrollArea);
+    if(pImageView){
+      *ptr=reinterpret_cast<void*>(pImageView);
+      return SWIG_TypeQuery("FXImageView *");
+      }
+    FXList *pList=dynamic_cast<FXList*>(*ppScrollArea);
+    if(pList){
+      *ptr=reinterpret_cast<void*>(pList);
+      return SWIG_TypeQuery("FXList *");
+      }
+    FXMDIClient *pMDIClient=dynamic_cast<FXMDIClient*>(*ppScrollArea);
+    if(pMDIClient){
+      *ptr=reinterpret_cast<void*>(pMDIClient);
+      return SWIG_TypeQuery("FXMDIClient *");
+      }
+    FXScrollWindow *pScrollWindow=dynamic_cast<FXScrollWindow*>(*ppScrollArea);
+    if(pScrollWindow){
+      *ptr=reinterpret_cast<void*>(pScrollWindow);
+      return SWIG_TypeQuery("FXScrollWindow *");
+      }
+    FXTable *pTable=dynamic_cast<FXTable*>(*ppScrollArea);
+    if(pTable){
+      *ptr=reinterpret_cast<void*>(pTable);
+      return SWIG_TypeQuery("FXTable *");
+      }
+    FXText *pText=dynamic_cast<FXText*>(*ppScrollArea);
+    if(pText){
+      *ptr=reinterpret_cast<void*>(pText);
+      return SWIG_TypeQuery("FXText *");
+      }
+    FXTreeList *pTreeList=dynamic_cast<FXTreeList*>(*ppScrollArea);
+    if(pTreeList){
+      *ptr=reinterpret_cast<void*>(pTreeList);
+      return SWIG_TypeQuery("FXTreeList *");
+      }
+    return 0;
+}
+%}
+
+DYNAMIC_CAST(SWIGTYPE_p_FXScrollArea, FXScrollArea_dynamic_cast);
+

data/swig-interfaces/FXScrollBar.i

@@ -0,0 +1,178 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001 by J. Lyle Johnson. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+/// ScrollBar styles
+enum {
+  SCROLLBAR_VERTICAL   = 0,             /// Vertically oriented
+  SCROLLBAR_HORIZONTAL = 0x00020000,    /// Horizontally oriented
+  SCROLLBAR_WHEELJUMP  = 0x00040000     /// Mouse wheel jumps instead of sliding smoothly
+  };
+
+
+%rename("barSize")  FXScrollBar::getBarSize() const;
+%rename("barSize=") FXScrollBar::setBarSize(FXint);
+
+/**
+* The scroll bar is used when a document has a larger content than may be made
+* visible.  The range is the total size of the document, the page is the part
+* of the document which is visible.  The size of the scrollbar thumb is adjusted
+* to give feedback of the relative sizes of each.
+* The scroll bar may be manipulated by the left mouse button (normal scrolling), by the
+* middle mouse button (same as the left mouse only the scroll position can jump to the
+* place where the click is made), or by the right mouse button (vernier- or fine-scrolling).
+* Holding down the control key while scrolling with the left or middle mouse button also
+* enables vernier-scrolling mode.  The vernier-scrolling mode is very useful for accurate
+* positioning in large documents.
+* Finally, if the mouse sports a wheel, the scroll bar can be manipulated by means
+* of the mouse wheel as well.  Holding down the Control-key during wheel motion
+* will cause the scrolling to go faster than normal.
+* While moving the scroll bar, a message of type SEL_CHANGED will be sent to the
+* target, and the message data will reflect the current position of type FXint.
+* At the end of the interaction, the scroll bar will send a message of type
+* SEL_COMMAND to notify the target of the final position.
+*/
+class FXScrollBar : public FXWindow {
+public:
+  long onPaint(FXObject*,FXSelector,void* PTR_EVENT);
+  long onMotion(FXObject*,FXSelector,void* PTR_EVENT);
+  long onMouseWheel(FXObject*,FXSelector,void* PTR_EVENT);
+  long onLeftBtnPress(FXObject*,FXSelector,void* PTR_EVENT);
+  long onLeftBtnRelease(FXObject*,FXSelector,void* PTR_EVENT);
+  long onMiddleBtnPress(FXObject*,FXSelector,void* PTR_EVENT);
+  long onMiddleBtnRelease(FXObject*,FXSelector,void* PTR_EVENT);
+  long onRightBtnPress(FXObject*,FXSelector,void* PTR_EVENT);
+  long onRightBtnRelease(FXObject*,FXSelector,void* PTR_EVENT);
+  long onUngrabbed(FXObject*,FXSelector,void* PTR_EVENT);
+  long onTimeWheel(FXObject*,FXSelector,void* PTR_IGNORE);
+  long onAutoScroll(FXObject*,FXSelector,void* PTR_INT);
+  long onCmdSetValue(FXObject*,FXSelector,void* PTR_INT);
+  long onCmdSetIntValue(FXObject*,FXSelector,void* PTR_PINT);
+  long onCmdGetIntValue(FXObject*,FXSelector,void* PTR_IGNORE); // FIXME
+  long onCmdSetIntRange(FXObject*,FXSelector,void* PTR_INTRANGE_IN);
+  long onCmdGetIntRange(FXObject*,FXSelector,void* PTR_INTRANGE_OUT);
+public:
+  enum{
+    ID_TIMEWHEEL=FXWindow::ID_LAST,
+    ID_AUTOSCROLL,
+    ID_LAST
+    };
+public:
+  %extend {
+    /// Construct scroll bar
+    FXScrollBar(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=SCROLLBAR_VERTICAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbScrollBar(p,tgt,sel,opts,x,y,w,h);
+      }
+    }
+
+  /// Set content size range
+  void setRange(FXint r);
+
+  /// Return content size range
+  FXint getRange() const;
+
+  /// Set viewport page size
+  void setPage(FXint p);
+
+  /// Return page size
+  FXint getPage() const;
+
+  /// Set scroll increment for line
+  void setLine(FXint l);
+
+  /// Return line increment
+  FXint getLine() const;
+
+  /// Change current scroll position
+  void setPosition(FXint p);
+
+  %extend {
+    /// Return scroll position
+    FXint position() const {
+      return self->getPosition();
+      }
+    }
+
+  /// Change highlight color
+  void setHiliteColor(FXColor clr);
+
+  /// Return highlight color
+  FXColor getHiliteColor() const;
+
+  /// Change shadow color
+  void setShadowColor(FXColor clr);
+
+  /// Return shadow color
+  FXColor getShadowColor() const;
+
+  /// Return border color
+  FXColor getBorderColor() const;
+
+  /// Change border color
+  void setBorderColor(FXColor clr);
+
+  /// Change the scrollbar style
+  FXuint getScrollBarStyle() const;
+
+  /// Get the current scrollbar style
+  void setScrollBarStyle(FXuint style);
+
+  /// Change the bar size
+  void setBarSize(FXint size);
+
+  /// Return the bar size
+  FXint getBarSize() const;
+
+  /// Destructor
+  virtual ~FXScrollBar();
+  };
+
+
+DECLARE_FXOBJECT_VIRTUALS(FXScrollBar)
+DECLARE_FXID_VIRTUALS(FXScrollBar)
+DECLARE_FXDRAWABLE_VIRTUALS(FXScrollBar)
+DECLARE_FXWINDOW_VIRTUALS(FXScrollBar)
+
+
+/// Corner between scroll bars
+class FXScrollCorner : public FXWindow {
+protected:
+  FXScrollCorner();
+public:
+  long onPaint(FXObject*,FXSelector,void* PTR_EVENT);
+public:
+  %extend {
+    /// Constructor
+    FXScrollCorner(FXComposite* p){
+      return new FXRbScrollCorner(p);
+      }
+    }
+
+  /// Destructor
+  virtual ~FXScrollCorner();
+  };
+
+
+DECLARE_FXOBJECT_VIRTUALS(FXScrollCorner)
+DECLARE_FXID_VIRTUALS(FXScrollCorner)
+DECLARE_FXDRAWABLE_VIRTUALS(FXScrollCorner)
+DECLARE_FXWINDOW_VIRTUALS(FXScrollCorner)
+