ruby-iup 0.0.2 → 0.1.0

data/ext/iup-linux/include/im_math_op.h

@@ -1,219 +1,214 @@
-/** \file
- * \brief Math Operations
- *
- * See Copyright Notice in im_lib.h
- */
-
-#ifndef __IM_MATH_OP_H
-#define __IM_MATH_OP_H
-
-#include "im_complex.h"
-
-//#define IM_NEARZERO 0.0000001f
-//#define IM_NEARINF   10000000
-
-/// Crop value to Byte limit
-template <class T>
-inline T crop_byte(const T& v)
-{
-  return v <= 0? 0: v <= 255? v: 255;
-}
-
-/// Generic Addition with 2 template types
-template <class T1, class T2>
-inline T1 add_op(const T1& v1, const T2& v2)
-{
-  return v2 + v1;
-}
-
-/// Generic Subtraction with 2 template types
-template <class T1, class T2>
-inline T1 sub_op(const T1& v1, const T2& v2)
-{
-  return v2 - v1;
-}
-
-/// Generic Multiplication with 2 template types
-template <class T1, class T2>
-inline T1 mul_op(const T1& v1, const T2& v2)
-{
-  return v2 * v1;
-}
-
-/// Generic Division with 2 template types
-template <class T1, class T2>
-inline T1 div_op(const T1& v1, const T2& v2)
-{
-//  if (v2 == 0) return (T1)IM_NEARINF;
-  return v1 / v2;
-}
-
-/// Generic Invert
-template <class T>
-inline T inv_op(const T& v)
-{
-//  if (v == 0) return (T)IM_NEARINF;
-  return 1/v;
-}
-
-/// Generic Difference with 2 template types
-template <class T1, class T2>
-inline T1 diff_op(const T1& v1, const T2& v2)
-{
-  if (v1 <= v2)
-    return v2 - v1;
-  return v1 - v2;
-}
-
-/// Generic Minimum with 2 template types
-template <class T1, class T2>
-inline T1 min_op(const T1& v1, const T2& v2)
-{
-  if (v1 <= v2)
-    return v1;
-  return v2;
-}
-
-/// Generic Maximum with 2 template types
-template <class T1, class T2>
-inline T1 max_op(const T1& v1, const T2& v2)
-{
-  if (v1 <= v2)
-    return v2;
-  return v1;
-}
-
-inline imbyte pow_op(const imbyte& v1, const imbyte& v2)
-{
-  return (imbyte)pow((float)v1, v2);
-}
-
-inline imushort pow_op(const imushort& v1, const imushort& v2)
-{
-  return (imushort)pow((float)v1, v2);
-}
-
-inline int pow_op(const int& v1, const int& v2)
-{
-  return (int)pow((float)v1, v2);
-}
-
-/// Generic Power with 2 template types
-template <class T1, class T2>
-inline T1 pow_op(const T1& v1, const T2& v2)
-{
-  return (T1)pow(v1, v2);
-}
-
-/// Generic Abssolute
-template <class T>
-inline T abs_op(const T& v)
-{
-  if (v <= 0)
-    return -1*v;
-  return v;
-}
-
-/// Generic Less
-template <class T>
-inline T less_op(const T& v)
-{
-  return -1*v;
-}
-
-/// Generic Square
-template <class T>
-inline T sqr_op(const T& v)
-{
-  return v*v;
-}
-
-inline int sqrt(const int& C)
-{
-  return (int)sqrt(float(C));
-}
-
-/// Generic Square Root
-template <class T>
-inline T sqrt_op(const T& v)
-{
-  return (T)sqrt(v);
-}
-
-inline int exp(const int& v)
-{
-  return (int)exp((float)v);
-}
-
-/// Generic Exponential
-template <class T>
-inline T exp_op(const T& v)
-{
-  return (T)exp(v);
-}
-
-inline int log(const int& v)
-{
-  return (int)log((float)v);
-}
-
-/// Generic Logarithm
-template <class T>
-inline T log_op(const T& v)
-{
-//  if (v <= 0) return (T)IM_NEARINF;
-  return (T)log(v);
-}
-
-// Dummy sin
-inline imcfloat sin(const imcfloat& v)
-{
-  return (v);
-}
-
-inline int sin(const int& v)
-{
-  return (int)sin((float)v);
-}
-
-/// Generic Sine
-template <class T>
-inline T sin_op(const T& v)
-{
-  return (T)sin(v);
-}
-
-inline int cos(const int& v)
-{
-  return (int)cos((float)v);
-}
-
-// Dummy cos
-inline imcfloat cos(const imcfloat& v)
-{
-  return (v);
-}
-
-/// Generic Cosine
-template <class T>
-inline T cos_op(const T& v)
-{
-  return (T)cos(v);
-}
-
-/// Sets a bit in an array
-inline void imDataBitSet(imbyte* data, int index, int bit)
-{
-  if (bit)
-    data[index / 8] |=  (0x01 << (7 - (index % 8)));
-  else
-    data[index / 8] &= ~(0x01 << (7 - (index % 8)));
-}
-
-/// Gets a bit from an array
-inline int imDataBitGet(imbyte* data, int index)
-{
-  return (data[index / 8] >> (7 - (index % 8))) & 0x01;
-}
-
-#endif
+/** \file
+ * \brief Math Operations
+ *
+ * See Copyright Notice in im_lib.h
+ */
+
+#ifndef __IM_MATH_OP_H
+#define __IM_MATH_OP_H
+
+#include "im_complex.h"
+
+
+/// Crop value to Byte limit
+template <class T>
+inline T crop_byte(const T& v)
+{
+  return v < 0? 0: v > 255? 255: v;
+}
+
+/// Generic Addition with 2 template types
+template <class T1, class T2>
+inline T1 add_op(const T1& v1, const T2& v2)
+{
+  return v2 + v1;
+}
+
+/// Generic Subtraction with 2 template types
+template <class T1, class T2>
+inline T1 sub_op(const T1& v1, const T2& v2)
+{
+  return v2 - v1;
+}
+
+/// Generic Multiplication with 2 template types
+template <class T1, class T2>
+inline T1 mul_op(const T1& v1, const T2& v2)
+{
+  return v2 * v1;
+}
+
+/// Generic Division with 2 template types
+template <class T1, class T2>
+inline T1 div_op(const T1& v1, const T2& v2)
+{
+  return v1 / v2;
+}
+
+/// Generic Invert
+template <class T>
+inline T inv_op(const T& v)
+{
+  return 1/v;
+}
+
+/// Generic Difference with 2 template types
+template <class T1, class T2>
+inline T1 diff_op(const T1& v1, const T2& v2)
+{
+  if (v1 < v2)
+    return v2 - v1;
+  return v1 - v2;
+}
+
+/// Generic Minimum with 2 template types
+template <class T1, class T2>
+inline T1 min_op(const T1& v1, const T2& v2)
+{
+  if (v1 < v2)
+    return v1;
+  return v2;
+}
+
+/// Generic Maximum with 2 template types
+template <class T1, class T2>
+inline T1 max_op(const T1& v1, const T2& v2)
+{
+  if (v1 < v2)
+    return v2;
+  return v1;
+}
+
+inline imbyte pow_op(const imbyte& v1, const imbyte& v2)
+{
+  return (imbyte)pow((float)v1, v2);
+}
+
+inline imushort pow_op(const imushort& v1, const imushort& v2)
+{
+  return (imushort)pow((float)v1, v2);
+}
+
+inline int pow_op(const int& v1, const int& v2)
+{
+  return (int)pow((float)v1, v2);
+}
+
+/// Generic Power with 2 template types
+template <class T1, class T2>
+inline T1 pow_op(const T1& v1, const T2& v2)
+{
+  return (T1)pow(v1, v2);
+}
+
+/// Generic Abssolute
+template <class T>
+inline T abs_op(const T& v)
+{
+  if (v < 0)
+    return -1*v;
+  return v;
+}
+
+/// Generic Less
+template <class T>
+inline T less_op(const T& v)
+{
+  return -1*v;
+}
+
+/// Generic Square
+template <class T>
+inline T sqr_op(const T& v)
+{
+  return v*v;
+}
+
+inline int sqrt(const int& C)
+{
+  return (int)sqrt(float(C));
+}
+
+/// Generic Square Root
+template <class T>
+inline T sqrt_op(const T& v)
+{
+  return (T)sqrt(v);
+}
+
+inline int exp(const int& v)
+{
+  return (int)exp((float)v);
+}
+
+/// Generic Exponential
+template <class T>
+inline T exp_op(const T& v)
+{
+  return (T)exp(v);
+}
+
+inline int log(const int& v)
+{
+  return (int)log((float)v);
+}
+
+/// Generic Logarithm
+template <class T>
+inline T log_op(const T& v)
+{
+  return (T)log(v);
+}
+
+// Dummy sin
+inline imcfloat sin(const imcfloat& v)
+{
+  return (v);
+}
+
+inline int sin(const int& v)
+{
+  return (int)sin((float)v);
+}
+
+/// Generic Sine
+template <class T>
+inline T sin_op(const T& v)
+{
+  return (T)sin(v);
+}
+
+inline int cos(const int& v)
+{
+  return (int)cos((float)v);
+}
+
+// Dummy cos
+inline imcfloat cos(const imcfloat& v)
+{
+  return (v);
+}
+
+/// Generic Cosine
+template <class T>
+inline T cos_op(const T& v)
+{
+  return (T)cos(v);
+}
+
+/// Sets a bit in an array
+inline void imDataBitSet(imbyte* data, int index, int bit)
+{
+  if (bit)
+    data[index / 8] |=  (0x01 << (7 - (index % 8)));
+  else
+    data[index / 8] &= ~(0x01 << (7 - (index % 8)));
+}
+
+/// Gets a bit from an array
+inline int imDataBitGet(imbyte* data, int index)
+{
+  return (data[index / 8] >> (7 - (index % 8))) & 0x01;
+}
+
+#endif

data/ext/iup-linux/include/im_palette.h

@@ -1,172 +1,172 @@
-/** \file
- * \brief Palette Generators
- *
- * See Copyright Notice in im_lib.h
- */
-
-#ifndef __IM_PALETTE_H
-#define __IM_PALETTE_H
-
-#if	defined(__cplusplus)
-extern "C" {
-#endif
-
-
-/** \defgroup palette Palette Generators
- * \par
- * Creates several standard palettes. The palette is just an array of encoded color values.
- * See also \ref colorutl.
- * \par
- * In Lua, to create a palette you can call im.PaletteCreate.
- * \verbatim im.PaletteCreate([count: number]) -> pal: imPalette [in Lua 5] \endverbatim
- * Default count is 256.
- * IMLua and CDLua palettes are 100% compatible. The IM palette metatable name is "imPalette". \n
- * When converted to a string will return "imPalete(%p)" where %p is replaced by the userdata address.
- * If the palette is already destroyed by im.PaletteDestroy, then it will return also the suffix "-destroyed".
- * \par
- * In Lua, to destroy a palette you can call im.PaletteDestroy.
- * If this function is not called, the palette is destroyed by the garbage collector.
- * \verbatim im.PaletteDestroy(pal: imPalette) [in Lua 5] \endverbatim
- * \par
- * In Lua, array access is enabled so you can do:.
- * \verbatim color = pal[index] \endverbatim
- * \verbatim pal[index] = color \endverbatim
- * \verbatim count = #pal \endverbatim
- * \par
- * See \ref im_palette.h
- * \ingroup util */
-
-
-/** Searches for the nearest color on the table and returns the color index if successful. 
- * It looks in all palette entries and finds the minimum euclidian square distance. 
- * If the color matches the given color it returns immediately.
- * See also \ref colorutl.
- *
- * \verbatim im.PaletteFindNearest(pal: imPalette, color: lightuserdata) -> index: number [in Lua 5] \endverbatim
- * \ingroup palette */
-int imPaletteFindNearest(const long *palette, int palette_count, long color);
-
-/** Searches for the color on the table and returns the color index if successful. 
- * If the tolerance is 0 search for the exact match in the palette else search for the 
- * first color that fits in the tolerance range.
- * See also \ref colorutl.
- *
- * \verbatim im.PaletteFindColor(pal: imPalette, color: lightuserdata, tol: number) -> index: number [in Lua 5] \endverbatim
- * \ingroup palette */
-int imPaletteFindColor(const long *palette, int palette_count, long color, unsigned char tol);
-
-/** Creates a palette of gray scale values.
- * The colors are arranged from black to white.
- *
- * \verbatim im.PaletteGray() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteGray(void);
-
-/** Creates a palette of a gradient of red colors.
- * The colors are arranged from black to pure red.
- *
- * \verbatim im.PaletteRed() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteRed(void);
-
-/** Creates a palette of a gradient of green colors.
- * The colors are arranged from black to pure green.
- *
- * \verbatim im.PaletteGreen() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteGreen(void);
-
-/** Creates a palette of a gradient of blue colors.
- * The colors are arranged from black to pure blue.
- *
- * \verbatim im.PaletteBlue() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteBlue(void);
-
-/** Creates a palette of a gradient of yellow colors.
- * The colors are arranged from black to pure yellow.
- *
- * \verbatim im.PaletteYellow() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteYellow(void);
-
-/** Creates a palette of a gradient of magenta colors.
- * The colors are arranged from black to pure magenta.
- *
- * \verbatim im.PaletteMagenta() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteMagenta(void);
-
-/** Creates a palette of a gradient of cian colors.
- * The colors are arranged from black to pure cian.
- *
- * \verbatim im.PaletteCian() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteCian(void);
-
-/** Creates a palette of rainbow colors.
- * The colors are arranged in the light wave length spectrum order (starting from purple).
- *
- * \verbatim im.PaletteRainbow() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteRainbow(void);
-
-/** Creates a palette of hues with maximum saturation.
- *
- * \verbatim im.PaletteHues() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteHues(void);
-
-/** Creates a palette of a gradient of blue colors.
- * The colors are arranged from pure blue to white.
- *
- * \verbatim im.PaletteBlueIce() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteBlueIce(void);
-
-/** Creates a palette of a gradient from black to white passing trough red and orange.
- *
- * \verbatim im.PaletteHotIron() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteHotIron(void);
-
-/** Creates a palette of a gradient from black to white passing trough red and yellow.
- *
- * \verbatim im.PaletteBlackBody() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteBlackBody(void);
-
-/** Creates a palette with high contrast colors.
- *
- * \verbatim im.PaletteHighContrast() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteHighContrast(void);
-
-/** Creates a palette of an uniform range of colors from black to white.
- *  This is a 2^(2.6) bits per pixel palette.
- *
- * \verbatim im.PaletteUniform() -> pal: imPalette [in Lua 5] \endverbatim
- * \ingroup palette */
-long* imPaletteUniform(void);
-
-/** Returns the index of the correspondent RGB color of an uniform palette.
- *
- * \verbatim im.PaletteUniformIndex(color: lightuserdata) -> index: number [in Lua 5] \endverbatim
- * \ingroup palette */
-int imPaletteUniformIndex(long color);
-
-/** Returns the index of the correspondent RGB color of an uniform palette.
- * Uses an 8x8 ordered dither to lookup the index in a halftone matrix.
- * The spatial position used by the halftone method.
- *
- * \verbatim im.PaletteUniformIndexHalftoned(color: lightuserdata, x: number, y: number) -> index: number [in Lua 5] \endverbatim
- * \ingroup palette */
-int imPaletteUniformIndexHalftoned(long color, int x, int y);
-
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif
-
+/** \file
+ * \brief Palette Generators
+ *
+ * See Copyright Notice in im_lib.h
+ */
+
+#ifndef __IM_PALETTE_H
+#define __IM_PALETTE_H
+
+#if	defined(__cplusplus)
+extern "C" {
+#endif
+
+
+/** \defgroup palette Palette Generators
+ * \par
+ * Creates several standard palettes. The palette is just an array of encoded color values.
+ * See also \ref colorutl.
+ * \par
+ * In Lua, to create a palette you can call im.PaletteCreate.
+ * \verbatim im.PaletteCreate([count: number]) -> pal: imPalette [in Lua 5] \endverbatim
+ * Default count is 256.
+ * IMLua and CDLua palettes are 100% compatible. The IM palette metatable name is "imPalette". \n
+ * When converted to a string will return "imPalete(%p)" where %p is replaced by the userdata address.
+ * If the palette is already destroyed by im.PaletteDestroy, then it will return also the suffix "-destroyed".
+ * \par
+ * In Lua, to destroy a palette you can call im.PaletteDestroy.
+ * If this function is not called, the palette is destroyed by the garbage collector.
+ * \verbatim im.PaletteDestroy(pal: imPalette) [in Lua 5] \endverbatim
+ * \par
+ * In Lua, array access is enabled so you can do:.
+ * \verbatim color = pal[index] \endverbatim
+ * \verbatim pal[index] = color \endverbatim
+ * \verbatim count = #pal \endverbatim
+ * \par
+ * See \ref im_palette.h
+ * \ingroup util */
+
+
+/** Searches for the nearest color on the table and returns the color index if successful. 
+ * It looks in all palette entries and finds the minimum euclidian square distance. 
+ * If the color matches the given color it returns immediately.
+ * See also \ref colorutl.
+ *
+ * \verbatim im.PaletteFindNearest(pal: imPalette, color: lightuserdata) -> index: number [in Lua 5] \endverbatim
+ * \ingroup palette */
+int imPaletteFindNearest(const long *palette, int palette_count, long color);
+
+/** Searches for the color on the table and returns the color index if successful. 
+ * If the tolerance is 0 search for the exact match in the palette else search for the 
+ * first color that fits in the tolerance range.
+ * See also \ref colorutl.
+ *
+ * \verbatim im.PaletteFindColor(pal: imPalette, color: lightuserdata, tol: number) -> index: number [in Lua 5] \endverbatim
+ * \ingroup palette */
+int imPaletteFindColor(const long *palette, int palette_count, long color, unsigned char tol);
+
+/** Creates a palette of gray scale values.
+ * The colors are arranged from black to white.
+ *
+ * \verbatim im.PaletteGray() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteGray(void);
+
+/** Creates a palette of a gradient of red colors.
+ * The colors are arranged from black to pure red.
+ *
+ * \verbatim im.PaletteRed() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteRed(void);
+
+/** Creates a palette of a gradient of green colors.
+ * The colors are arranged from black to pure green.
+ *
+ * \verbatim im.PaletteGreen() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteGreen(void);
+
+/** Creates a palette of a gradient of blue colors.
+ * The colors are arranged from black to pure blue.
+ *
+ * \verbatim im.PaletteBlue() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteBlue(void);
+
+/** Creates a palette of a gradient of yellow colors.
+ * The colors are arranged from black to pure yellow.
+ *
+ * \verbatim im.PaletteYellow() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteYellow(void);
+
+/** Creates a palette of a gradient of magenta colors.
+ * The colors are arranged from black to pure magenta.
+ *
+ * \verbatim im.PaletteMagenta() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteMagenta(void);
+
+/** Creates a palette of a gradient of cian colors.
+ * The colors are arranged from black to pure cian.
+ *
+ * \verbatim im.PaletteCian() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteCian(void);
+
+/** Creates a palette of rainbow colors.
+ * The colors are arranged in the light wave length spectrum order (starting from purple).
+ *
+ * \verbatim im.PaletteRainbow() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteRainbow(void);
+
+/** Creates a palette of hues with maximum saturation.
+ *
+ * \verbatim im.PaletteHues() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteHues(void);
+
+/** Creates a palette of a gradient of blue colors.
+ * The colors are arranged from pure blue to white.
+ *
+ * \verbatim im.PaletteBlueIce() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteBlueIce(void);
+
+/** Creates a palette of a gradient from black to white passing trough red and orange.
+ *
+ * \verbatim im.PaletteHotIron() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteHotIron(void);
+
+/** Creates a palette of a gradient from black to white passing trough red and yellow.
+ *
+ * \verbatim im.PaletteBlackBody() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteBlackBody(void);
+
+/** Creates a palette with high contrast colors.
+ *
+ * \verbatim im.PaletteHighContrast() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteHighContrast(void);
+
+/** Creates a palette of an uniform range of colors from black to white.
+ *  This is a 2^(2.6) bits per pixel palette.
+ *
+ * \verbatim im.PaletteUniform() -> pal: imPalette [in Lua 5] \endverbatim
+ * \ingroup palette */
+long* imPaletteUniform(void);
+
+/** Returns the index of the correspondent RGB color of an uniform palette.
+ *
+ * \verbatim im.PaletteUniformIndex(color: lightuserdata) -> index: number [in Lua 5] \endverbatim
+ * \ingroup palette */
+int imPaletteUniformIndex(long color);
+
+/** Returns the index of the correspondent RGB color of an uniform palette.
+ * Uses an 8x8 ordered dither to lookup the index in a halftone matrix.
+ * The spatial position used by the halftone method.
+ *
+ * \verbatim im.PaletteUniformIndexHalftoned(color: lightuserdata, x: number, y: number) -> index: number [in Lua 5] \endverbatim
+ * \ingroup palette */
+int imPaletteUniformIndexHalftoned(long color, int x, int y);
+
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
+