rwx 0.0.1.dev

data/ext/wxPen.hpp

@@ -0,0 +1,37 @@
+/*
+ * wxPen.hpp
+ *
+ *  Created on: 16.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXPEN_HPP_
+#define WXPEN_HPP_
+
+#include "main.hpp"
+
+extern VALUE rb_cWXPen;
+void Init_WXPen(VALUE rb_mWX);
+
+template <>
+VALUE wrap< wxPen >(wxPen *bitmap );
+
+template <>
+VALUE wrap< wxPen >(const wxPen &bitmap );
+
+template <>
+wxPen* unwrap< wxPen* >(const VALUE &vbitmap);
+
+template <>
+wxPen unwrap< wxPen >(const VALUE &vbitmap);
+
+
+namespace RubyWX {
+namespace Pen {
+
+void define_const();
+
+}
+}
+
+#endif /* WXPEN_HPP_ */

data/ext/wxPickerBase.cpp

@@ -0,0 +1,121 @@
+/*
+ * wxPickerBase.cpp
+ *
+ *  Created on: 04.03.2012
+ *      Author: hanmac
+ */
+#include "wxPickerBase.hpp"
+#include "wxTextCtrl.hpp"
+
+VALUE rb_cWXPickerBase;
+
+#if wxUSE_CONTROLS
+
+template <>
+wxPickerBase* unwrap<wxPickerBase*>(const VALUE &arg)
+{
+	return unwrapTypedPtr<wxPickerBase>(arg,rb_cWXPickerBase);
+}
+
+#define _self unwrap<wxPickerBase*>(self)
+
+namespace RubyWX {
+namespace PickerBase {
+
+macro_attr_con(InternalMargin,int,_self->HasTextCtrl())
+macro_attr_con(TextCtrlProportion,int,_self->HasTextCtrl())
+macro_attr(PickerCtrlProportion,int)
+macro_attr_bool_con(TextCtrlGrowable,HasTextCtrl)
+macro_attr_bool(PickerCtrlGrowable)
+
+macro_attr(TextCtrl,wxTextCtrl*)
+macro_attr(PickerCtrl,wxControl*)
+
+
+void set_style_flags(VALUE hash,int& flags)
+{
+
+	set_hash_flag_option(hash,"use_textctrl",wxPB_USE_TEXTCTRL,flags);
+	set_hash_flag_option(hash,"small",wxPB_SMALL,flags);
+
+}
+
+
+}
+}
+
+#endif
+
+
+/* Document-attr: text_ctrl_growable
+ * true if the text control is growable. true/false
+ */
+/* Document-attr: picker_ctrl_growable
+ * true if the picker control is growable. true/false
+ */
+/* Document-attr: text_ctrl_proportion
+ * the proportion value of the text control. Integer
+ */
+/* Document-attr: picker_ctrl_proportion
+ * the proportion value of the picker. Integer
+ */
+/* Document-attr: text_ctrl
+ * the text control. WX::TextCtrl / nil
+ */
+/* Document-attr: picker_ctrl
+ * the picker control. WX::Control / nil
+ */
+/* Document-attr: internal_margin
+ * the margin (in pixel) between the picker and the text control. Integer
+ */
+
+/* Document-const: USE_TEXTCTRL
+ *   Creates a text control to the left of the picker which is completely managed by this WX::PickerBase class.
+ */
+/* Document-const: SMALL
+ *   Use smaller version of the control with a small "..." button
+ */
+DLL_LOCAL void Init_WXPickerBase(VALUE rb_mWX)
+{
+#if 0
+	rb_mWX = rb_define_module("WX");
+	rb_cWXWindow = rb_define_class_under(rb_mWX,"Window",rb_cObject);
+
+	rb_cWXControl = rb_define_class_under(rb_mWX,"Control",rb_cWXWindow);
+
+	rb_define_attr(rb_cWXPickerBase,"internal_margin",1,1);
+
+	rb_define_attr(rb_cWXPickerBase,"text_ctrl",1,1);
+	rb_define_attr(rb_cWXPickerBase,"picker_ctrl",1,1);
+
+	rb_define_attr(rb_cWXPickerBase,"text_ctrl_proportion",1,1);
+	rb_define_attr(rb_cWXPickerBase,"picker_ctrl_proportion",1,1);
+
+	rb_define_attr(rb_cWXPickerBase,"text_ctrl_growable",1,1);
+	rb_define_attr(rb_cWXPickerBase,"picker_ctrl_growable",1,1);
+
+#endif
+
+#if wxUSE_CONTROLS
+	using namespace RubyWX::PickerBase;
+	rb_cWXPickerBase = rb_define_class_under(rb_mWX,"PickerBase",rb_cWXControl);
+	rb_undef_alloc_func(rb_cWXPickerBase);
+
+	rb_define_attr_method(rb_cWXPickerBase,"internal_margin",_getInternalMargin,_setInternalMargin);
+
+	rb_define_attr_method(rb_cWXPickerBase,"text_ctrl",_getTextCtrl,_setTextCtrl);
+	rb_define_attr_method(rb_cWXPickerBase,"picker_ctrl",_getPickerCtrl,_setPickerCtrl);
+
+	rb_define_attr_method(rb_cWXPickerBase,"text_ctrl_proportion",_getTextCtrlProportion,_setTextCtrlProportion);
+	rb_define_attr_method(rb_cWXPickerBase,"picker_ctrl_proportion",_getPickerCtrlProportion,_setPickerCtrlProportion);
+
+	rb_define_attr_method(rb_cWXPickerBase,"text_ctrl_growable",_getTextCtrlGrowable,_setTextCtrlGrowable);
+	rb_define_attr_method(rb_cWXPickerBase,"picker_ctrl_growable",_getPickerCtrlGrowable,_setPickerCtrlGrowable);
+
+	rb_define_const(rb_cWXPickerBase,"USE_TEXTCTRL",INT2NUM(wxPB_USE_TEXTCTRL));
+	rb_define_const(rb_cWXPickerBase,"SMALL",INT2NUM(wxPB_SMALL));
+#endif
+
+}
+
+

data/ext/wxPickerBase.hpp

@@ -0,0 +1,28 @@
+/*
+ * wxPickerBase.hpp
+ *
+ *  Created on: 04.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXPICKERBASE_HPP_
+#define WXPICKERBASE_HPP_
+
+#include "wxControl.hpp"
+#include <wx/pickerbase.h>
+
+extern VALUE rb_cWXPickerBase;
+
+void Init_WXPickerBase(VALUE rb_mWX);
+
+
+namespace RubyWX {
+namespace PickerBase {
+
+void set_style_flags(VALUE hash,int& flags);
+
+}
+}
+
+
+#endif /* WXPICKERBASE_HPP_ */

data/ext/wxPoint.cpp

@@ -0,0 +1,224 @@
+/*
+ * wxRealPoint.cpp
+ *
+ *  Created on: 21.04.2012
+ *      Author: hanmac
+ */
+
+#include "wxPoint.hpp"
+VALUE rb_cwxPoint;
+
+ID rwxID_x,rwxID_y;
+
+#define _self unwrap<wxRealPoint*>(self)
+
+
+template <>
+VALUE wrap< wxRealPoint >(wxRealPoint *point )
+{
+	return wrapTypedPtr(point, rb_cwxPoint);
+}
+
+template <>
+VALUE wrap< wxPoint >(const wxPoint &point )
+{
+	return wrap(new wxRealPoint(point));
+}
+
+template <>
+bool is_wrapable< wxRealPoint >(const VALUE &vpoint)
+{
+	if (rb_obj_is_kind_of(vpoint, rb_cwxPoint)){
+		return true;
+	}else if(rb_respond_to(vpoint,rwxID_x) &&
+		rb_respond_to(vpoint,rwxID_y)){
+		return true;
+	}else
+		return false;
+}
+template <>
+bool is_wrapable< wxPoint >(const VALUE &vpoint)
+{
+	return is_wrapable< wxRealPoint >(vpoint);
+}
+
+template <>
+wxRealPoint unwrap< wxRealPoint >(const VALUE &vpoint)
+{
+	if(rb_obj_is_kind_of(vpoint, rb_cArray)){
+		wxRealPoint point;
+		point.x = NUM2DBL(RARRAY_AREF(vpoint,0));
+		point.y = NUM2DBL(RARRAY_AREF(vpoint,1));
+		return point;
+	}else if(!rb_obj_is_kind_of(vpoint, rb_cwxPoint) &&
+		rb_respond_to(vpoint,rwxID_x) &&
+		rb_respond_to(vpoint,rwxID_y)){
+		wxRealPoint point;
+		point.x = NUM2DBL(rb_funcall(vpoint,rwxID_x,0));
+		point.y = NUM2DBL(rb_funcall(vpoint,rwxID_y,0));
+		return point;
+	}else{
+		return *unwrap<wxRealPoint*>(vpoint);
+	}
+
+}
+
+
+template <>
+wxPoint unwrap< wxPoint >(const VALUE &vpoint)
+{
+	if(rb_obj_is_kind_of(vpoint, rb_cArray)){
+		wxPoint point;
+		point.x = NUM2INT(RARRAY_AREF(vpoint,0));
+		point.y = NUM2INT(RARRAY_AREF(vpoint,1));
+		return point;
+	}else if(!rb_obj_is_kind_of(vpoint, rb_cwxPoint) &&
+		rb_respond_to(vpoint,rwxID_x) &&
+		rb_respond_to(vpoint,rwxID_y)){
+		wxPoint point;
+		point.x = NUM2INT(rb_funcall(vpoint,rwxID_x,0));
+		point.y = NUM2INT(rb_funcall(vpoint,rwxID_y,0));
+		return point;
+	}else{
+		return *unwrap<wxRealPoint*>(vpoint);
+	}
+
+}
+
+template <>
+wxPointList* unwrap< wxPointList* >(const VALUE &val)
+{
+	wxPointList *result = new wxPointList;
+	VALUE dp(rb_Array(val));
+	std::size_t length = RARRAY_LEN(dp);
+	for(std::size_t i = 0; i < length; ++i)
+		result->Append(new wxPoint(unwrap<wxPoint>(RARRAY_AREF(dp,i))));
+	return result;
+}
+
+namespace RubyWX {
+namespace Point {
+
+macro_attr_prop(x,double)
+macro_attr_prop(y,double)
+
+DLL_LOCAL VALUE _alloc(VALUE self)
+{
+	return wrap(new wxRealPoint());
+}
+
+DLL_LOCAL VALUE _initialize(VALUE self,VALUE x,VALUE y)
+{
+	_set_x(self,x);
+	_set_y(self,y);
+	return self;
+}
+
+/*
+*/
+DLL_LOCAL VALUE _initialize_copy(VALUE self, VALUE other)
+{
+	VALUE result = rb_call_super(1,&other);
+	_set_x(self,_get_x(other));
+	_set_y(self,_get_y(other));
+	return result;
+}
+
+/* Document-method: inspect
+ * call-seq:
+ *   inspect -> String
+ *
+ * Human-readable description.
+ * ===Return value
+ * String
+*/
+DLL_LOCAL VALUE _inspect(VALUE self)
+{
+	return rb_sprintf( "%s(%f, %f)",
+		rb_obj_classname( self ),
+		NUM2DBL(_get_x(self)),
+		NUM2DBL(_get_y(self)));
+}
+
+/* Document-method: marshal_dump
+ * call-seq:
+ *   marshal_dump -> Array
+ *
+ * Provides marshalling support for use by the Marshal library.
+ * ===Return value
+ * Array
+ */
+DLL_LOCAL VALUE _marshal_dump(VALUE self)
+{
+    VALUE ptr[2];
+    ptr[0] = _get_x(self);
+    ptr[1] = _get_y(self);
+    return rb_ary_new4(2, ptr);
+}
+
+/* Document-method: marshal_load
+ * call-seq:
+ *   marshal_load(array) -> nil
+ *
+ * Provides marshalling support for use by the Marshal library.
+ *
+ *
+ */
+DLL_LOCAL VALUE _marshal_load(VALUE self, VALUE data)
+{
+    _set_x(self, RARRAY_AREF(data,0));
+    _set_y(self, RARRAY_AREF(data,1));
+    return Qnil;
+}
+
+
+}
+}
+
+
+
+/* Document-class: WX::Point
+ *
+ * This class represents an Point.
+ */
+
+/* Document-attr: x
+ * returns the x value of Point.
+ */
+/* Document-attr: y
+ * returns the y value of Point.
+ */
+
+/**/
+DLL_LOCAL void Init_WXPoint(VALUE rb_mWX)
+{
+
+#if 0
+	rb_define_attr(rb_cwxPoint,"x",1,1);
+	rb_define_attr(rb_cwxPoint,"y",1,1);
+#endif
+
+	using namespace RubyWX::Point;
+	rb_cwxPoint = rb_define_class_under(rb_mWX,"Point",rb_cObject);
+
+	rb_define_alloc_func(rb_cwxPoint,_alloc);
+
+	rb_define_method(rb_cwxPoint,"initialize",RUBY_METHOD_FUNC(_initialize),2);
+	rb_define_private_method(rb_cwxPoint,"initialize_copy",RUBY_METHOD_FUNC(_initialize_copy),1);
+
+	rb_define_attr_method(rb_cwxPoint,"x",_get_x,_set_x);
+	rb_define_attr_method(rb_cwxPoint,"y",_get_y,_set_y);
+
+	rb_define_method(rb_cwxPoint,"inspect",RUBY_METHOD_FUNC(_inspect),0);
+
+	rb_define_method(rb_cwxPoint,"marshal_dump",RUBY_METHOD_FUNC(_marshal_dump),0);
+	rb_define_method(rb_cwxPoint,"marshal_load",RUBY_METHOD_FUNC(_marshal_load),1);
+
+	registerType<wxRealPoint>(rb_cwxPoint, true);
+
+	rwxID_x = rb_intern("x");
+	rwxID_y = rb_intern("y");
+}
+
+
+

data/ext/wxPoint.hpp

@@ -0,0 +1,40 @@
+/*
+ * wxPoint.hpp
+ *
+ *  Created on: 21.04.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXPOINT_HPP_
+#define WXPOINT_HPP_
+
+#include "main.hpp"
+
+extern VALUE rb_cWXPoint;
+DLL_LOCAL void Init_WXPoint(VALUE rb_mWX);
+
+extern ID rwxID_x,rwxID_y;
+
+template <>
+VALUE wrap< wxRealPoint >(wxRealPoint *point );
+
+template <>
+bool is_wrapable< wxRealPoint >(const VALUE &vpoint);
+
+template <>
+wxRealPoint unwrap< wxRealPoint >(const VALUE &vpoint);
+
+template <>
+VALUE wrap< wxPoint >(const wxPoint &point );
+
+template <>
+bool is_wrapable< wxPoint >(const VALUE &vpoint);
+
+template <>
+wxPoint unwrap< wxPoint >(const VALUE &vpoint);
+
+template <>
+wxPointList* unwrap< wxPointList* >(const VALUE &vpoint);
+
+
+#endif /* WXPOINT_HPP_ */