fxruby 1.6.20-x86-linux

data/swig-interfaces/FXDial.i

@@ -0,0 +1,168 @@
+/***********************************************************************
+ * 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".
+ ***********************************************************************/
+
+// Dial style options
+enum {
+  DIAL_VERTICAL   = 0,                            // Vertically oriented
+  DIAL_HORIZONTAL = 0x00008000,                   // Horizontal oriented
+  DIAL_CYCLIC     = 0x00010000,                   // Value wraps around
+  DIAL_HAS_NOTCH  = 0x00020000,                   // Dial has a Center Notch
+  DIAL_NORMAL     = DIAL_VERTICAL
+  };
+
+
+/// Dial
+class FXDial : public FXFrame {
+protected:
+  FXint         range[2];                         // Reported data range
+  FXColor       notchColor;                       // Main notch color
+  FXint         notchangle;                       // Angle of main notch
+  FXint         notchspacing;                     // Angle between notches
+  FXint         notchoffset;                      // Notch offset
+  FXint         dragpoint;                        // Place where clicked
+  FXint         dragpos;                          // Value where clicked
+  FXint         incr;                             // Rate of change/revolution
+  FXint         pos;                              // Reported data position
+  FXString      help;                             // Help string
+  FXString      tip;                              // Tip string
+protected:
+  FXDial(){}
+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 onKeyPress(FXObject*,FXSelector,void* PTR_EVENT);
+  long onKeyRelease(FXObject*,FXSelector,void* PTR_EVENT);
+  long onUngrabbed(FXObject*,FXSelector,void* PTR_EVENT);
+  long onCmdSetValue(FXObject*,FXSelector,void* PTR_INT);
+  long onCmdSetIntValue(FXObject*,FXSelector,void* PTR_PINT);
+  long onCmdGetIntValue(FXObject*,FXSelector,void* PTR_NULL); // FIXME
+  long onCmdSetRealValue(FXObject*,FXSelector,void* PTR_PDOUBLE);
+  long onCmdGetRealValue(FXObject*,FXSelector,void* PTR_NULL); // FIXME
+  long onCmdSetIntRange(FXObject*,FXSelector,void* PTR_INTRANGE_IN);
+  long onCmdGetIntRange(FXObject*,FXSelector,void* PTR_INTRANGE_OUT);
+  long onCmdSetRealRange(FXObject*,FXSelector,void* PTR_DBLRANGE_IN);
+  long onCmdGetRealRange(FXObject*,FXSelector,void* PTR_DBLRANGE_OUT);
+  long onCmdSetHelp(FXObject*,FXSelector,void* PTR_STRING);
+  long onCmdGetHelp(FXObject*,FXSelector,void* PTR_IGNORE); // FIXME
+  long onCmdSetTip(FXObject*,FXSelector,void* PTR_STRING);
+  long onCmdGetTip(FXObject*,FXSelector,void* PTR_IGNORE); // FIXME
+  long onQueryHelp(FXObject*,FXSelector,void* PTR_IGNORE);
+  long onQueryTip(FXObject*,FXSelector,void* PTR_IGNORE);
+public:
+  %extend {
+    /// Construct a dial widget
+    FXDial(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=DIAL_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbDial(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+    }
+
+  /// Set the dial value
+  void setValue(FXint value,FXbool notify=FALSE);
+  
+  /// Return the dial value
+  FXint getValue() const;
+
+  %extend {
+    /// Change the dial's range
+    void setRange(VALUE range, FXbool notify=FALSE){
+      FXint lo,hi;
+      FXRbRange2LoHi(range,lo,hi);
+      self->setRange(lo,hi,notify);
+      }
+        
+    /// Obtain the current range of the dial
+    VALUE getRange() const {
+      FXint lo,hi;
+      self->getRange(lo,hi);
+      return rb_range_new(INT2NUM(lo),INT2NUM(hi),0);
+      }
+  }
+
+  /**
+  * Set the revolution increment, which is the amount of change
+  * in the position for revolution of the dial; the dial may go
+  * through multiple revolutions to go through its whole range;
+  * by default it takes one 360 degree turn of the dial to go
+  * from the lower to the upper range.
+  */
+  void setRevolutionIncrement(FXint i);
+
+  /// Get the current value of the revolution increment
+  FXint getRevolutionIncrement() const;
+
+  /**
+  * Change the spacing for the small notches; this should be set 
+  * in tenths of degrees in the range [1,3600], and the value should
+  * be a divisor of 3600, so as to make the notches come out evenly
+  */
+  void setNotchSpacing(FXint spacing);
+
+  /// Get the current notch spacing
+  FXint getNotchSpacing() const;
+
+  /**
+  * Change the notch offset, which is the position of the 
+  * center notch; the value should be tenths of degrees 
+  * in the range [-3600,3600]
+  */
+  void setNotchOffset(FXint offset);
+
+  /// Get the current center notch offset
+  FXint getNotchOffset() const;
+
+  /// Changes the dial style.
+  void setDialStyle(FXuint opts);
+
+  /// Get the current dial style.
+  FXuint getDialStyle() const;
+
+  /// Change the center notch color
+  void setNotchColor(FXColor clr);
+
+  /// Get the current center notch color
+  FXColor getNotchColor() const;
+
+  /// Set the help text to be displayed on the status line
+  void setHelpText(const FXString& text);
+  
+  /// Get the current help text
+  const FXString& getHelpText() const;
+
+  /// Set the tip text to be displayed in the tooltip
+  void setTipText(const FXString& text);
+  
+  /// Get the current tooltip text value
+  const FXString& getTipText() const;
+  
+  /// Destructor
+  virtual ~FXDial();
+  };
+
+
+DECLARE_FXOBJECT_VIRTUALS(FXDial)
+DECLARE_FXID_VIRTUALS(FXDial)
+DECLARE_FXDRAWABLE_VIRTUALS(FXDial)
+DECLARE_FXWINDOW_VIRTUALS(FXDial)
+

data/swig-interfaces/FXDialogBox.i

@@ -0,0 +1,131 @@
+/***********************************************************************
+ * 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".
+ ***********************************************************************/
+
+/**
+* DialogBox window.
+* When receiving ID_CANCEL or ID_ACCEPT, the DialogBox breaks out of the 
+* modal loop and returns FALSE or TRUE, respectively.
+* To close the DialogBox when not running modally, simply send it ID_HIDE.
+*/
+class FXDialogBox : public FXTopWindow {
+protected:
+  FXDialogBox(){}
+public:
+  long onKeyPress(FXObject*,FXSelector,void* PTR_EVENT);
+  long onKeyRelease(FXObject*,FXSelector,void* PTR_EVENT);
+  long onCmdAccept(FXObject*,FXSelector,void* PTR_IGNORE);
+  long onCmdCancel(FXObject*,FXSelector,void* PTR_IGNORE);
+public:
+  enum {
+    ID_CANCEL=FXTopWindow::ID_LAST,     /// Closes the dialog, cancel the entry
+    ID_ACCEPT,                          /// Closes the dialog, accept the entry
+    ID_LAST
+    };
+public:
+  %extend {
+    /// Construct free-floating dialog
+    FXDialogBox(FXApp* APP,const FXString& name,FXuint opts=DECOR_TITLE|DECOR_BORDER,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=10,FXint pr=10,FXint pt=10,FXint pb=10,FXint hs=4,FXint vs=4){
+      return new FXRbDialogBox(APP,name,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+  
+    /// Construct dialog which will always float over the owner window
+    FXDialogBox(FXWindow* OWNER,const FXString& name,FXuint opts=DECOR_TITLE|DECOR_BORDER,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=10,FXint pr=10,FXint pt=10,FXint pb=10,FXint hs=4,FXint vs=4){
+      return new FXRbDialogBox(OWNER,name,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+    }
+  
+  /// Destructor
+  virtual ~FXDialogBox();
+  };
+
+
+DECLARE_FXOBJECT_VIRTUALS(FXDialogBox)
+DECLARE_FXID_VIRTUALS(FXDialogBox)
+DECLARE_FXDRAWABLE_VIRTUALS(FXDialogBox)
+DECLARE_FXWINDOW_VIRTUALS(FXDialogBox)
+DECLARE_FXTOPWINDOW_VIRTUALS(FXDialogBox)
+DECLARE_FXDIALOGBOX_VIRTUALS(FXDialogBox)
+
+%{
+static swig_type_info *FXDialogBox_dynamic_cast(void **ptr) {
+    FXDialogBox **ppDialogBox = reinterpret_cast<FXDialogBox **>(ptr);
+    FXChoiceBox *pChoiceBox=dynamic_cast<FXChoiceBox*>(*ppDialogBox);
+    if(pChoiceBox){
+      *ptr=reinterpret_cast<void*>(pChoiceBox);
+      return SWIG_TypeQuery("FXChoiceBox *");
+      }
+    FXColorDialog *pColorDialog=dynamic_cast<FXColorDialog*>(*ppDialogBox);
+    if(pColorDialog){
+      *ptr=reinterpret_cast<void*>(pColorDialog);
+      return SWIG_TypeQuery("FXColorDialog *");
+      }
+    FXDirDialog *pDirDialog=dynamic_cast<FXDirDialog*>(*ppDialogBox);
+    if(pDirDialog){
+      *ptr=reinterpret_cast<void*>(pDirDialog);
+      return SWIG_TypeQuery("FXDirDialog *");
+      }
+    FXFileDialog *pFileDialog=dynamic_cast<FXFileDialog*>(*ppDialogBox);
+    if(pFileDialog){
+      *ptr=reinterpret_cast<void*>(pFileDialog);
+      return SWIG_TypeQuery("FXFileDialog *");
+      }
+    FXFontDialog *pFontDialog=dynamic_cast<FXFontDialog*>(*ppDialogBox);
+    if(pFontDialog){
+      *ptr=reinterpret_cast<void*>(pFontDialog);
+      return SWIG_TypeQuery("FXFontDialog *");
+      }
+    FXInputDialog *pInputDialog=dynamic_cast<FXInputDialog*>(*ppDialogBox);
+    if(pInputDialog){
+      *ptr=reinterpret_cast<void*>(pInputDialog);
+      return SWIG_TypeQuery("FXInputDialog *");
+      }
+    FXMessageBox *pMessageBox=dynamic_cast<FXMessageBox*>(*ppDialogBox);
+    if(pMessageBox){
+      *ptr=reinterpret_cast<void*>(pMessageBox);
+      return SWIG_TypeQuery("FXMessageBox *");
+      }
+    FXPrintDialog *pPrintDialog=dynamic_cast<FXPrintDialog*>(*ppDialogBox);
+    if(pPrintDialog){
+      *ptr=reinterpret_cast<void*>(pPrintDialog);
+      return SWIG_TypeQuery("FXPrintDialog *");
+      }
+    FXProgressDialog *pProgressDialog=dynamic_cast<FXProgressDialog*>(*ppDialogBox);
+    if(pProgressDialog){
+      *ptr=reinterpret_cast<void*>(pProgressDialog);
+      return SWIG_TypeQuery("FXProgressDialog *");
+      }
+    FXReplaceDialog *pReplaceDialog=dynamic_cast<FXReplaceDialog*>(*ppDialogBox);
+    if(pReplaceDialog){
+      *ptr=reinterpret_cast<void*>(pReplaceDialog);
+      return SWIG_TypeQuery("FXReplaceDialog *");
+      }
+    FXWizard *pWizard=dynamic_cast<FXWizard*>(*ppDialogBox);
+    if(pWizard){
+      *ptr=reinterpret_cast<void*>(pWizard);
+      return SWIG_TypeQuery("FXWizard *");
+      }
+    return 0;
+}
+%}
+
+DYNAMIC_CAST(SWIGTYPE_p_FXDialogBox, FXDialogBox_dynamic_cast);
+

data/swig-interfaces/FXDict.i

@@ -0,0 +1,200 @@
+/***********************************************************************
+ * 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".
+ ***********************************************************************/
+
+// Rename these functions
+%rename("getTotalSize")	FXDict::size() const;
+%rename("setTotalSize")	FXDict::size(FXint);
+%rename("length")	FXDict::no() const;
+
+// Mark these as predicate methods
+%predicate FXDict::has_key(const FXchar* ky) const;
+
+
+/**
+* The dictionary class maintains a fast-access hash table of entities
+* indexed by a character string.  
+* It is typically used to map strings to pointers; however, overloading
+* the createData() and deleteData() members allows any type of data to
+* be indexed by strings.
+*/
+class FXDict : public FXObject {
+protected:
+  struct FXDictEntry {
+    FXchar *key;              // Key string
+    void   *data;             // Data
+    FXint   hash;             // Hash value of key
+    bool  mark;             // Entry is marked
+    };
+protected:
+  FXDictEntry *dict;          // Dictionary
+  FXint        total;         // Dictionary size
+  FXint        number;        // Number of entries
+protected:
+  
+  /**
+  * Overload this function in a derived class to return the
+  * data pointer given an input pointer; the default implementation
+  * just returns the input pointer.
+  */
+  virtual void *createData(const void*);
+
+  /**
+  * Overload this function in a derived class to delete the pointer
+  * previously returned by createData(); the default implementation
+  * does nothing.
+  */
+  virtual void deleteData(void*);
+
+public:
+  %extend {
+    /**
+    * Construct an empty dictionary.
+    */
+    FXDict(){
+      return new FXRbDict();
+      }
+    }
+
+  /**
+  * Return the size of the table, including the empty slots.
+  */
+  FXint size() const;
+
+  /** 
+  * Resize the table to the given size.
+  */
+  void size(FXint m);
+  
+  /**
+  * Return the total number of entries in the table.
+  */
+  FXint no() const;
+
+  /**
+  * Insert a new entry into the table given key and mark.
+  * If there is already an entry with that key, leave it unchanged,
+  * otherwise insert the new entry.
+  */
+  // void* insert(const FXchar* ky,const void* ptr,bool mrk=false);
+  
+  /**
+  * Replace data at key, if the entry's mark is less than
+  * or equal to the given mark.  If there was no existing entry,
+  * a new entry is inserted with the given mark.
+  */
+  // void* replace(const FXchar* ky,const void* ptr,bool mrk=false);
+  
+  /**
+  * Remove data given key.
+  */
+  void* remove(const FXchar* ky);
+  
+  /**
+  * Find data pointer given key.
+  */
+  // void* find(const FXchar* ky) const;
+
+  /**
+  * Return key at position pos.
+  */
+  const FXchar* key(FXuint pos) const;
+
+  /**
+  * return data pointer at position pos.
+  */
+  // void* data(FXuint pos) const;
+
+  /**
+  * Return mark flag of entry at position pos.
+  */
+  bool mark(FXuint pos) const;
+
+  /**
+  * Return position of first filled slot, or >= total
+  */
+  FXint first() const;
+
+  /**
+  * Return position of last filled slot or -1
+  */
+  FXint last() const;
+  
+  /**
+  * Return position of next filled slot in hash table
+  * or a value greater than or equal to total if no filled 
+  * slot was found
+  */
+  FXint next(FXint pos) const;  
+  
+  /**
+  * Return position of previous filled slot in hash table
+  * or a -1 if no filled slot was found
+  */
+  FXint prev(FXint pos) const;  
+  
+  /// Clear all entries
+  void clear();
+  
+  // Add methods similar to those for Ruby's Hash class
+  %extend {
+    // Returns true if the given key is present
+    bool has_key(const FXchar* ky) const {
+      return (self->find(ky) != 0);
+    }
+  }
+
+  /// Destructor
+  virtual ~FXDict();
+  };
+
+
+DECLARE_FXOBJECT_VIRTUALS(FXDict)
+
+%{
+static swig_type_info *FXDict_dynamic_cast(void **ptr) {
+    FXDict **ppDict = reinterpret_cast<FXDict **>(ptr);
+    FXFileDict *pFileDict=dynamic_cast<FXFileDict*>(*ppDict);
+    if(pFileDict){
+      *ptr=reinterpret_cast<void*>(pFileDict);
+      return SWIG_TypeQuery("FXFileDict *");
+      }
+    FXIconDict *pIconDict=dynamic_cast<FXIconDict*>(*ppDict);
+    if(pIconDict){
+      *ptr=reinterpret_cast<void*>(pIconDict);
+      return SWIG_TypeQuery("FXIconDict *");
+      }
+    FXSettings *pSettings=dynamic_cast<FXSettings*>(*ppDict);
+    if(pSettings){
+      *ptr=reinterpret_cast<void*>(pSettings);
+      return SWIG_TypeQuery("FXSettings *");
+      }
+    FXStringDict *pStringDict=dynamic_cast<FXStringDict*>(*ppDict);
+    if(pStringDict){
+      *ptr=reinterpret_cast<void*>(pStringDict);
+      return SWIG_TypeQuery("FXStringDict *");
+      }
+    return 0;
+}
+%}
+
+DYNAMIC_CAST(SWIGTYPE_p_FXDict, FXDict_dynamic_cast);
+