fxruby 1.6.20-x86-linux

data/swig-interfaces/FXComposeContext.i

@@ -0,0 +1,66 @@
+/********************************************************************************
+*                                                                               *
+*                         C o m p o s e - C o n t e x t                         *
+*                                                                               *
+*********************************************************************************
+* Copyright (C) 2005 by Jeroen van der Zijp.   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.    *
+*********************************************************************************
+* $Id: FXComposeContext.i 2292 2005-12-06 02:22:28Z lyle $                   *
+********************************************************************************/
+
+
+/**
+* Compose Context manages the state of an input method
+* if input method support is enabled.
+*/
+class FXComposeContext : public FXId {
+protected:
+  FXWindow  *window;            // Window we belong to
+  FXSelector message;           // Message to send it
+protected:
+  FXComposeContext();
+public:
+
+  %extend {
+    /// Construct compose context for given window
+    FXComposeContext(FXApp* a,FXWindow* win=NULL,FXSelector sel=0){
+      return new FXRbComposeContext(a,win,sel);
+      }
+  }
+
+  /// Focus in
+  void focusIn();
+
+  /// Focus out
+  void focusOut();
+
+  /// Set the spot
+  void setSpot(FXint x,FXint y);
+
+  /// Set the area
+  void setArea(FXint x,FXint y,FXint w,FXint h);
+
+  /// Translate key event
+  FXString translateEvent(FXRawEvent& event);
+
+  /// Destructor
+  virtual ~FXComposeContext();
+  };
+
+}
+
+#endif

data/swig-interfaces/FXComposite.i

@@ -0,0 +1,103 @@
+/***********************************************************************
+ * 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".
+ ***********************************************************************/
+
+
+/// Base composite
+class FXComposite : public FXWindow {
+protected:
+  FXComposite(){}
+  FXComposite(FXApp* a,FXVisual *vis);
+  FXComposite(FXApp* a,FXWindow* own,FXuint opts,FXint x,FXint y,FXint w,FXint h);
+public:
+  long onKeyPress(FXObject*,FXSelector,void* PTR_EVENT);
+  long onKeyRelease(FXObject*,FXSelector,void* PTR_EVENT);
+  long onFocusNext(FXObject*,FXSelector,void* PTR_EVENT);
+  long onFocusPrev(FXObject*,FXSelector,void* PTR_EVENT);
+  long onCmdUpdate(FXObject*,FXSelector,void* PTR_EVENT);
+public:
+  %extend {
+    /// Constructor
+    FXComposite(FXComposite* p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbComposite(p,opts,x,y,w,h);
+      }
+    }
+
+  /// Return the width of the widest child window
+  FXint maxChildWidth() const;
+
+  /// Return the height of the tallest child window
+  FXint maxChildHeight() const;
+
+  /// Destructor
+  virtual ~FXComposite();
+  };
+
+
+DECLARE_FXOBJECT_VIRTUALS(FXComposite)
+DECLARE_FXID_VIRTUALS(FXComposite)
+DECLARE_FXDRAWABLE_VIRTUALS(FXComposite)
+DECLARE_FXWINDOW_VIRTUALS(FXComposite)
+
+%{
+static swig_type_info *FXComposite_dynamic_cast(void **ptr) {
+    FXComposite **ppComposite = reinterpret_cast<FXComposite **>(ptr);
+    FX4Splitter *p4Splitter=dynamic_cast<FX4Splitter*>(*ppComposite);
+    if(p4Splitter){
+      *ptr=reinterpret_cast<void*>(p4Splitter);
+      return SWIG_TypeQuery("FX4Splitter *");
+      }
+    FXMDIChild *pMDIChild=dynamic_cast<FXMDIChild*>(*ppComposite);
+    if(pMDIChild){
+      *ptr=reinterpret_cast<void*>(pMDIChild);
+      return SWIG_TypeQuery("FXMDIChild *");
+      }
+    FXPacker *pPacker=dynamic_cast<FXPacker*>(*ppComposite);
+    if(pPacker){
+      *ptr=reinterpret_cast<void*>(pPacker);
+      return SWIG_TypeQuery("FXPacker *");
+      }
+    FXRootWindow *pRootWindow=dynamic_cast<FXRootWindow*>(*ppComposite);
+    if(pRootWindow){
+      *ptr=reinterpret_cast<void*>(pRootWindow);
+      return SWIG_TypeQuery("FXRootWindow *");
+      }
+    FXScrollArea *pScrollArea=dynamic_cast<FXScrollArea*>(*ppComposite);
+    if(pScrollArea){
+      *ptr=reinterpret_cast<void*>(pScrollArea);
+      return SWIG_TypeQuery("FXScrollArea *");
+      }
+    FXShell *pShell=dynamic_cast<FXShell*>(*ppComposite);
+    if(pShell){
+      *ptr=reinterpret_cast<void*>(pShell);
+      return SWIG_TypeQuery("FXShell *");
+      }
+    FXSplitter *pSplitter=dynamic_cast<FXSplitter*>(*ppComposite);
+    if(pSplitter){
+      *ptr=reinterpret_cast<void*>(pSplitter);
+      return SWIG_TypeQuery("FXSplitter *");
+      }
+    return 0;
+}
+%}
+
+DYNAMIC_CAST(SWIGTYPE_p_FXComposite, FXComposite_dynamic_cast);
+

data/swig-interfaces/FXCursor.i

@@ -0,0 +1,120 @@
+/***********************************************************************
+ * 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".
+ ***********************************************************************/
+
+// Stock cursors
+enum FXStockCursor {
+  CURSOR_ARROW=1,                   // Default left pointing arrow
+  CURSOR_RARROW,                    // Right arrow
+  CURSOR_IBEAM,                     // Text I-Beam
+  CURSOR_WATCH,                     // Stopwatch or hourglass
+  CURSOR_CROSS,                     // Crosshair
+  CURSOR_UPDOWN,                    // Move up, down
+  CURSOR_LEFTRIGHT,                 // Move left, right
+  CURSOR_MOVE                       // Move up,down,left,right
+  };
+
+
+/// Cursor options
+enum {
+  CURSOR_KEEP  = 0x00000100,    /// Keep pixel data in client
+  CURSOR_OWNED = 0x00000200     /// Pixel data is owned by image
+  };
+
+
+/// Cursor class
+class FXCursor : public FXId {
+protected:
+  FXColor *data;              // Source data
+  FXint    width;             // Width
+  FXint    height;            // Height
+  FXint    hotx;              // Hot spot x
+  FXint    hoty;              // Hot spot y
+  FXuint   options;           // Options
+protected:
+  FXCursor();
+public:
+  %extend {
+    /// Make stock cursor
+    FXCursor(FXApp* a,FXStockCursor curid=CURSOR_ARROW){
+      return new FXRbCursor(a,curid);
+      }
+  
+    /// Make cursor from source and mask; cursor size should at most 32x32 for portability!
+    FXCursor(FXApp* a,const FXuchar* src,const FXuchar* msk,FXint w=32,FXint h=32,FXint hx=0,FXint hy=0){
+      return new FXRbCursor(a,src,msk,w,h,hx,hy);
+      }
+
+    /// Make cursor from FXColor pixels; cursor size should at most 32x32 for portability!
+    FXCursor(FXApp* a,const FXColor* pix,FXint w=32,FXint h=32,FXint hx=0,FXint hy=0){
+      return new FXRbCursor(a,pix,w,h,hx,hy);
+      }
+    }
+
+  /// Width of cursor
+  FXint getWidth() const;
+
+  /// Height of cursor
+  FXint getHeight() const;
+
+  /// Set hotspot x
+  void setHotX(FXint x);
+  
+  /// Get hotspot x
+  FXint getHotX() const;
+
+  /// Set hotspot y
+  void setHotY(FXint y);
+  
+  /// Get hotspot y
+  FXint getHotY() const;
+  
+  /// Check if there is color in the cursor
+  bool isColor() const;
+
+  /// Destructor
+  virtual ~FXCursor();
+  };
+
+
+DECLARE_FXOBJECT_VIRTUALS(FXCursor)
+DECLARE_FXID_VIRTUALS(FXCursor)
+DECLARE_FXCURSOR_VIRTUALS(FXCursor)
+
+%{
+static swig_type_info *FXCursor_dynamic_cast(void **ptr) {
+    FXCursor **ppCursor = reinterpret_cast<FXCursor **>(ptr);
+    FXCURCursor *pCURCursor=dynamic_cast<FXCURCursor*>(*ppCursor);
+    if(pCURCursor){
+      *ptr=reinterpret_cast<void*>(pCURCursor);
+      return SWIG_TypeQuery("FXCURCursor *");
+      }
+    FXGIFCursor *pGIFCursor=dynamic_cast<FXGIFCursor*>(*ppCursor);
+    if(pGIFCursor){
+      *ptr=reinterpret_cast<void*>(pGIFCursor);
+      return SWIG_TypeQuery("FXGIFCursor *");
+      }
+    return 0;
+}
+%}
+
+DYNAMIC_CAST(SWIGTYPE_p_FXCursor, FXCursor_dynamic_cast);
+

data/swig-interfaces/FXDC.i

@@ -0,0 +1,280 @@
+/***********************************************************************
+ * 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".
+ ***********************************************************************/
+
+/// Drawing (BITBLT) functions
+enum FXFunction {
+  BLT_CLR,                        /// D := 0
+  BLT_SRC_AND_DST,                /// D := S & D
+  BLT_SRC_AND_NOT_DST,            /// D := S & ~D
+  BLT_SRC,                        /// D := S
+  BLT_NOT_SRC_AND_DST,            /// D := ~S & D
+  BLT_DST,                        /// D := D
+  BLT_SRC_XOR_DST,                /// D := S ^ D
+  BLT_SRC_OR_DST,                 /// D := S | D
+  BLT_NOT_SRC_AND_NOT_DST,        /// D := ~S & ~D  ==  D := ~(S | D)
+  BLT_NOT_SRC_XOR_DST,            /// D := ~S ^ D
+  BLT_NOT_DST,                    /// D := ~D
+  BLT_SRC_OR_NOT_DST,             /// D := S | ~D
+  BLT_NOT_SRC,                    /// D := ~S
+  BLT_NOT_SRC_OR_DST,             /// D := ~S | D
+  BLT_NOT_SRC_OR_NOT_DST,         /// D := ~S | ~D  ==  ~(S & D)
+  BLT_SET                         /// D := 1
+  };
+
+
+/// Line Styles
+enum FXLineStyle {
+  LINE_SOLID,                     /// Solid lines
+  LINE_ONOFF_DASH,                /// On-off dashed lines
+  LINE_DOUBLE_DASH                /// Double dashed lines
+  };
+
+
+/// Line Cap Styles
+enum FXCapStyle {
+  CAP_NOT_LAST,                   /// Don't include last end cap
+  CAP_BUTT,                       /// Butting line end caps
+  CAP_ROUND,                      /// Round line end caps
+  CAP_PROJECTING                  /// Projecting line end caps
+  };
+
+
+/// Line Join Styles
+enum FXJoinStyle {
+  JOIN_MITER,                     /// Mitered or pointy joints
+  JOIN_ROUND,                     /// Round line joints
+  JOIN_BEVEL                      /// Beveled or flat joints
+  };
+
+
+/// Fill Styles
+enum FXFillStyle {
+  FILL_SOLID,                     /// Fill with solid color
+  FILL_TILED,                     /// Fill with tiled bitmap 
+  FILL_STIPPLED,                  /// Fill where stipple mask is 1
+  FILL_OPAQUESTIPPLED             /// Fill with foreground where mask is 1, background otherwise
+  };
+
+
+/// Fill Rules
+enum FXFillRule {
+  RULE_EVEN_ODD,                  /// Even odd polygon filling
+  RULE_WINDING                    /// Winding rule polygon filling
+  };
+
+
+/// Stipple/dither patterns
+enum FXStipplePattern {
+  STIPPLE_0         = 0,
+  STIPPLE_NONE      = 0,
+  STIPPLE_BLACK     = 0,            /// All ones
+  STIPPLE_1         = 1,
+  STIPPLE_2         = 2,
+  STIPPLE_3         = 3,
+  STIPPLE_4         = 4,
+  STIPPLE_5         = 5,
+  STIPPLE_6         = 6,
+  STIPPLE_7         = 7,
+  STIPPLE_8         = 8,
+  STIPPLE_GRAY      = 8,            /// 50% gray
+  STIPPLE_9         = 9,
+  STIPPLE_10        = 10,
+  STIPPLE_11        = 11,
+  STIPPLE_12        = 12,
+  STIPPLE_13        = 13,
+  STIPPLE_14        = 14,
+  STIPPLE_15        = 15,
+  STIPPLE_16        = 16,
+  STIPPLE_WHITE     = 16,           /// All zeroes
+  STIPPLE_HORZ      = 17,           /// Horizontal hatch pattern
+  STIPPLE_VERT      = 18,           /// Vertical hatch pattern
+  STIPPLE_CROSS     = 19,           /// Cross-hatch pattern
+  STIPPLE_DIAG      = 20,           /// Diagonal // hatch pattern
+  STIPPLE_REVDIAG   = 21,           /// Reverse diagonal \\ hatch pattern
+  STIPPLE_CROSSDIAG = 22            /// Cross-diagonal hatch pattern
+  };
+
+
+/// Line segment
+struct FXSegment {
+  %extend {
+    FXSegment(FXshort x1=0,FXshort y1=0,FXshort x2=0,FXshort y2=0){
+      FXSegment* seg=new FXSegment;
+      seg->x1=x1; seg->y1=y1; seg->x2=x2; seg->y2=y2;
+      return seg;
+      }
+    }
+  FXshort x1,y1,x2,y2;
+  ~FXSegment();
+  };
+
+
+/// Arc
+struct FXArc {
+  %extend {
+    FXArc(FXshort x=0,FXshort y=0,FXshort w=0,FXshort h=0,FXshort a=0,FXshort b=0){
+      FXArc* arc=new FXArc;
+      arc->x=x; arc->y=y; arc->w=w; arc->h=h; arc->a=a; arc->b=b;
+      return arc;
+      }
+    }
+  FXshort x,y,w,h,a,b;
+  ~FXArc();
+  };
+    
+
+class FXApp;
+class FXImage;
+class FXBitmap;
+class FXIcon;
+class FXFont;
+class FXDrawable;
+
+%ignore FXDC::context() const;
+%ignore FXDC::getDashLength() const;
+
+
+/**
+* Abstract Device Context
+*
+* A Device Context is used to maintain the state of the graphics drawing system. 
+* Defining your drawing code in terms of the Abstract Device Context allows the
+* drawing commands to be rendered on different types of surfaces, such as windows
+* and images (FXDCWindow), or on paper (FXDCPrint). 
+* WYSYWYG may be obtained by using the same identical drawing code in your
+* application regardless of the actual device surface being utilized. 
+*/
+class FXDC {
+private:
+  FXApp           *app;       // Application
+protected:
+  void            *ctx;       // Context handle
+  FXFont          *font;      // Drawing font
+  FXStipplePattern pattern;   // Stipple pattern
+  FXBitmap        *stipple;   // Stipple bitmap
+  FXImage         *tile;      // Tile image
+  FXBitmap        *mask;      // Mask bitmap
+  FXRectangle      clip;      // Clip rectangle
+  FXColor          fg;        // Foreground color
+  FXColor          bg;        // Background color
+  FXuint           width;     // Line width
+  FXCapStyle       cap;       // Line cap style
+  FXJoinStyle      join;      // Line join style
+  FXLineStyle      style;     // Line style
+  FXFillStyle      fill;      // Fill style
+  FXFillRule       rule;      // Fill rule
+  FXFunction       rop;       // RasterOp
+  FXchar           dashpat[32]; // Line dash pattern data
+  FXuint           dashlen;     // Line dash pattern length
+  FXuint           dashoff;     // Line dash pattern offset
+  FXint            tx;        // Tile dx
+  FXint            ty;        // Tile dy
+  FXint            cx;        // Clip x
+  FXint            cy;        // Clip y
+public:
+  %extend {
+    /// Construct dummy DC
+    FXDC(FXApp* a){
+      return new FXRbDC(a);
+      }
+    }
+  
+  /// Get context handle
+  void* context() const { return ctx; }
+  
+  /// Get application
+  FXApp* getApp() const;
+
+  /// Get foreground drawing color
+  FXColor getForeground() const;
+
+  /// Get background drawing color
+  FXColor getBackground() const;
+
+  %extend {
+    /// Get dash pattern
+    VALUE getDashPattern() const {
+      return FXRbMakeArray(self->getDashPattern(), self->getDashLength());
+      }
+    }
+
+  /// Get dash offset
+  FXuint getDashOffset() const;
+
+  /// Get dash length
+  FXuint getDashLength() const;
+  
+  /// Get line width
+  FXuint getLineWidth() const;
+  
+  /// Get line cap style
+  FXCapStyle getLineCap() const;
+  
+  /// Get line join style
+  FXJoinStyle getLineJoin() const;
+  
+  /// Get line style
+  FXLineStyle getLineStyle() const;
+  
+  /// Get fill style
+  FXFillStyle getFillStyle() const;
+  
+  /// Get fill rule
+  FXFillRule getFillRule() const;
+  
+  /// Get rasterop function
+  FXFunction getFunction() const;
+
+  /// Get the tile image
+  FXImage *getTile() const;
+  
+  /// Get stipple bitmap
+  FXBitmap *getStippleBitmap() const;
+  
+  /// Get pattern 
+  FXStipplePattern getStipplePattern() const;
+
+  /// Return clip rectangle
+  const FXRectangle& getClipRectangle() const;
+  
+  /// Return clip x
+  FXint getClipX() const;
+  
+  /// Return clip y
+  FXint getClipY() const;
+  
+  /// Return clip width
+  FXint getClipWidth() const;
+  
+  /// Return clip height
+  FXint getClipHeight() const;
+
+  /// Get text font 
+  FXFont* getFont() const;
+  
+  /// Destructor
+  virtual ~FXDC();
+  };
+
+
+DECLARE_FXDC_VIRTUALS(FXDC)
+