rwx 0.0.1.dev

data/ext/wxChoiceBook.hpp

@@ -0,0 +1,23 @@
+/*
+ * wxChoiceBook.hpp
+ *
+ *  Created on: 15.04.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXCHOICEBOOK_HPP_
+#define WXCHOICEBOOK_HPP_
+
+#include "wxEvtHandler.hpp"
+
+extern VALUE rb_cWXChoicebook;
+
+void Init_WXChoiceBookCtrl(VALUE rb_mWX);
+
+#if wxUSE_CHOICEBOOK
+#include <wx/choicebk.h>
+
+#endif
+
+
+#endif /* WXCHOICEBOOK_HPP_ */

data/ext/wxCollapsiblePane.cpp

@@ -0,0 +1,110 @@
+/*
+ * wxCollapsiblePane.cpp
+ *
+ *  Created on: 06.04.2012
+ *      Author: hanmac
+ */
+
+#include "wxEvtHandler.hpp"
+#include "wxControl.hpp"
+#include "wxCollapsiblePane.hpp"
+#include "wxCommandEvent.hpp"
+
+VALUE rb_cWXCollapsiblePane, rb_cWXCollapsiblePaneEvent;
+
+#if wxUSE_COLLPANE
+#define _self unwrap<wxCollapsiblePane*>(self)
+
+namespace RubyWX {
+namespace CollapsiblePane {
+
+APP_PROTECT(wxCollapsiblePane)
+
+macro_attr_bool2(Collapsed,Collapse)
+singlereturn(GetPane)
+
+/*
+ * call-seq:
+ *   CollapsiblePane.new(parent, name, [options])
+ *   CollapsiblePane.new(parent, [options])
+ *
+ * creates a new Window widget.
+ * ===Arguments
+ * * parent of this window or nil
+ * * name is a String describing a resource in a loaded xrc
+ *
+ * *options: Hash with possible options to set
+ *
+*/
+DLL_LOCAL VALUE _initialize(int argc,VALUE *argv,VALUE self)
+{
+	VALUE parent,name,hash;
+	rb_scan_args(argc, argv, "11:",&parent,&name,&hash);
+	if(!_created && !rb_obj_is_kind_of(name,rb_cString)){
+		wxWindowID id(wxID_ANY);
+		int style(wxCP_DEFAULT_STYLE);
+		wxString label;
+
+		if(rb_obj_is_kind_of(hash,rb_cHash))
+		{
+			set_hash_option(hash,"id",id,unwrapID);
+			set_hash_option(hash,"style",style);
+			set_hash_option(hash,"label",label);
+		}
+
+		_self->Create(unwrap<wxWindow*>(parent), id, label,
+			wxDefaultPosition, wxDefaultSize, style
+		);
+		
+	}
+	rb_call_super(argc,argv);
+	return self;
+}
+
+namespace Event
+{
+#undef _self
+#define _self unwrapTypedPtr<wxCollapsiblePaneEvent>(self,rb_cWXCollapsiblePaneEvent)
+macro_attr(Collapsed,bool)
+}
+
+}
+}
+#endif
+
+DLL_LOCAL void Init_WXCollapsiblePane(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_cWXCollapsiblePane,"collapsed",1,1);
+	rb_define_attr(rb_cWXCollapsiblePaneEvent,"collapsed",1,1);
+#endif
+#if wxUSE_COLLPANE
+	using namespace RubyWX::CollapsiblePane;
+	rb_cWXCollapsiblePane = rb_define_class_under(rb_mWX,"CollapsiblePane",rb_cWXControl);
+	rb_define_alloc_func(rb_cWXCollapsiblePane,_alloc);
+
+	rb_define_method(rb_cWXCollapsiblePane,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_attr_method(rb_cWXCollapsiblePane,"collapsed",_getCollapsed,_setCollapsed);
+
+	rb_define_method(rb_cWXCollapsiblePane,"pane",RUBY_METHOD_FUNC(_GetPane),0);
+
+	rb_cWXCollapsiblePaneEvent = rb_define_class_under(rb_cWXEvent,"CollapsiblePane",rb_cWXCommandEvent);
+
+	rb_define_attr_method(rb_cWXCollapsiblePaneEvent,"collapsed",Event::_getCollapsed,Event::_setCollapsed);
+
+
+	registerInfo<wxCollapsiblePane>(rb_cWXCollapsiblePane);
+
+	registerEventType("collapsiblepane_changed",wxEVT_COLLAPSIBLEPANE_CHANGED,rb_cWXCollapsiblePaneEvent);
+#endif
+}
+
+
+
+
+

data/ext/wxCollapsiblePane.hpp

@@ -0,0 +1,21 @@
+/*
+ * wxCollapsiblePane.hpp
+ *
+ *  Created on: 19.07.2014
+ *      Author: hanmac
+ */
+
+#ifndef WXCOLLAPSIBLEPANE_HPP_
+#define WXCOLLAPSIBLEPANE_HPP_
+
+
+#include "wxWindow.hpp"
+
+extern VALUE rb_cWXCollapsiblePane;
+DLL_LOCAL void Init_WXCollapsiblePane(VALUE rb_mWX);
+
+#if wxUSE_COLLPANE
+#include <wx/collpane.h>
+#endif
+
+#endif /* WXCOLLAPSIBLEPANE_HPP_ */

data/ext/wxColor.cpp

@@ -0,0 +1,435 @@
+/*
+ * wxColor.cpp
+ *
+ *  Created on: 15.02.2012
+ *      Author: hanmac
+ */
+
+#include "wxColor.hpp"
+
+#define _self unwrap<wxColor*>(self)
+
+VALUE rb_cWXColor;
+ID rwxID_red,rwxID_blue,rwxID_green,rwxID_alpha;
+
+template <>
+VALUE wrap< wxColor >(wxColor *color )
+{
+	return wrapTypedPtr(color, rb_cWXColor);
+}
+
+template <>
+bool is_wrapable< wxColor >(const VALUE &vcolor)
+{
+	if (rb_obj_is_kind_of(vcolor, rb_cWXColor) ||
+		rb_obj_is_kind_of(vcolor, rb_cString) || FIXNUM_P(vcolor)){
+		return true;
+	} else if(rb_respond_to(vcolor,rwxID_red) &&
+		rb_respond_to(vcolor,rwxID_blue) &&
+		rb_respond_to(vcolor,rwxID_green)){
+		return true;
+	}else
+		return false;
+}
+
+template <>
+wxColor* unwrap< wxColor* >(const VALUE &vcolor)
+{
+	return unwrapTypedPtr<wxColor>(vcolor, rb_cWXColor);
+}
+
+void set_color_part(char& cv,const VALUE &val, const ID &id)
+{
+	VALUE tmp = rb_funcall(val,id,0);
+	if(FIXNUM_P(tmp))
+		cv = NUM2CHR(tmp);
+	else
+		cv = NUM2DBL(tmp) * 256;
+}
+
+template <>
+wxColor unwrap< wxColor >(const VALUE &vcolor)
+{
+	if(rb_obj_is_kind_of(vcolor, rb_cString)){
+		wxLogNull logNo;
+		wxString name(unwrap<wxString>(vcolor));
+		wxColor col(name);
+		if(!col.IsOk())
+			rb_raise(
+				rb_eTypeError,
+				"%"PRIsVALUE" is not valid %"PRIsVALUE, vcolor, rb_cWXColor
+			);
+		return col;
+	}else if(FIXNUM_P(vcolor))
+		return wxColor(FIX2LONG(vcolor));
+	else if(!rb_obj_is_kind_of(vcolor, rb_cWXColor) &&
+		rb_respond_to(vcolor,rwxID_red) &&
+		rb_respond_to(vcolor,rwxID_green) &&
+		rb_respond_to(vcolor,rwxID_blue)){
+		char red,green,blue,alpha(wxALPHA_OPAQUE);
+		wxColor color;
+
+		set_color_part(red, vcolor, rwxID_red);
+		set_color_part(green, vcolor, rwxID_green);
+		set_color_part(blue, vcolor, rwxID_blue);
+
+		if(rb_respond_to(vcolor,rwxID_alpha)) {
+			set_color_part(alpha, vcolor, rwxID_alpha);
+		}
+
+		color.Set(red, green, blue, alpha);
+
+		return color;
+	}else{
+		return *unwrap<wxColor*>(vcolor);
+	}
+
+
+}
+
+namespace RubyWX {
+namespace Color {
+DLL_LOCAL VALUE _alloc(VALUE self) {
+	return wrap(new wxColor);
+}
+
+void define_const()
+{
+	if(rb_const_defined(rb_cWXColor,rb_intern("BLACK")))
+		return;
+
+	rb_define_const(rb_cWXColor,"BLACK",wrap(wxBLACK));
+	rb_define_const(rb_cWXColor,"BLUE",wrap(wxBLUE));
+	rb_define_const(rb_cWXColor,"CYAN",wrap(wxCYAN));
+	rb_define_const(rb_cWXColor,"GREEN",wrap(wxGREEN));
+	rb_define_const(rb_cWXColor,"YELLOW",wrap(wxYELLOW));
+	rb_define_const(rb_cWXColor,"LIGHT_GREY",wrap(wxLIGHT_GREY));
+	rb_define_const(rb_cWXColor,"RED",wrap(wxRED));
+	rb_define_const(rb_cWXColor,"WHITE",wrap(wxWHITE));
+}
+
+DLL_LOCAL VALUE _getRed(VALUE self)
+{
+	if(_self->IsOk())
+		return CHR2FIX(_self->Red());
+	else
+		return CHR2FIX(0);
+}
+
+DLL_LOCAL VALUE _getGreen(VALUE self)
+{
+	if(_self->IsOk())
+		return CHR2FIX(_self->Green());
+	else
+		return CHR2FIX(0);
+}
+
+DLL_LOCAL VALUE _getBlue(VALUE self)
+{
+	if(_self->IsOk())
+		return CHR2FIX(_self->Blue());
+	else
+		return CHR2FIX(0);
+}
+
+DLL_LOCAL VALUE _getAlpha(VALUE self)
+{
+	if(_self->IsOk())
+		return CHR2FIX(_self->Alpha());
+	else
+		return CHR2FIX(0);
+}
+
+DLL_LOCAL char val_to_char(VALUE val)
+{
+	char cval(0);
+	if(FIXNUM_P(val))
+		cval = NUM2CHR(val);
+	else
+		cval = NUM2DBL(val) * 256;
+	return cval;
+}
+
+DLL_LOCAL VALUE _setRed(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+
+	if(_self->IsOk())
+		_self->Set(val_to_char(val),_self->Green(),_self->Blue(),_self->Alpha());
+	else
+		_self->Set(val_to_char(val),0,0,0);
+	return val;
+}
+
+DLL_LOCAL VALUE _setGreen(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+	if(_self->IsOk())
+		_self->Set(_self->Red(),val_to_char(val),_self->Blue(),_self->Alpha());
+	else
+		_self->Set(0,val_to_char(val),0,0);
+	return val;
+}
+DLL_LOCAL VALUE _setBlue(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+	if(_self->IsOk())
+		_self->Set(_self->Red(),_self->Green(),val_to_char(val),_self->Alpha());
+	else
+		_self->Set(0,0,val_to_char(val),0);
+	return val;
+}
+DLL_LOCAL VALUE _setAlpha(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+
+	int red(0), green(0), blue(0), alpha(0);
+
+	if(_self->IsOk()) {
+		red = _self->Red();
+		green = _self->Green();
+		blue = _self->Blue();
+	}
+
+	if(!RTEST(val))
+		alpha = wxALPHA_OPAQUE;
+	else if(val == Qtrue)
+		alpha = wxALPHA_TRANSPARENT;
+	else
+		alpha = val_to_char(val);
+
+	_self->Set(red, green, blue, alpha);
+	return val;
+}
+
+DLL_LOCAL VALUE _tos(VALUE self)
+{
+	return wrap(wxToString(*_self));
+}
+
+DLL_LOCAL VALUE _name(VALUE self)
+{
+	if(wxColourDatabase *database = wxTheColourDatabase) {
+		wxString name(database->FindName(*_self).MakeLower());
+		if(name.empty())
+			return Qnil;
+		return wrap(name);
+	}
+	return Qnil;
+}
+
+
+/*
+ * call-seq:
+ *   Color.new(red,green,blue[,alpha])
+ *
+ * creates a new Color Object.
+*/
+DLL_LOCAL VALUE _initialize(int argc,VALUE *argv,VALUE self)
+{
+	VALUE red,green,blue,alpha;
+	rb_scan_args(argc, argv, "31",&red,&green,&blue,&alpha);
+	_setRed(self,red);
+	_setGreen(self,green);
+	_setBlue(self,blue);
+	_setAlpha(self, alpha);
+	return self;
+}
+/*
+*/
+DLL_LOCAL VALUE _initialize_copy(VALUE self, VALUE other)
+{
+	VALUE result = rb_call_super(1,&other);
+	_setRed(self,_getRed(other));
+	_setGreen(self,_getGreen(other));
+	_setBlue(self,_getBlue(other));
+	_setAlpha(self,_getAlpha(other));
+	return result;
+}
+
+/*
+ * call-seq:
+ *   inspect -> String
+ *
+ * Human-readable description.
+ * ===Return value
+ * String
+*/
+DLL_LOCAL VALUE _inspect(VALUE self)
+{
+	return rb_sprintf( "%s(%d, %d, %d, %d)",
+		rb_obj_classname( self ),
+		FIX2INT(_getRed(self)),
+		FIX2INT(_getGreen(self)),
+		FIX2INT(_getBlue(self)),
+		FIX2INT(_getAlpha(self))
+	);
+}
+
+/*
+ * 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[4];
+    ptr[0] = _getRed(self);
+    ptr[1] = _getGreen(self);
+    ptr[2] = _getBlue(self);
+    ptr[3] = _getAlpha(self);
+    return rb_ary_new4(4, ptr);
+}
+
+/*
+ * call-seq:
+ *   marshal_load(array) -> nil
+ *
+ * Provides marshalling support for use by the Marshal library.
+ *
+ *
+ */
+DLL_LOCAL VALUE _marshal_load(VALUE self, VALUE data)
+{
+    _setRed(self, RARRAY_AREF(data,0));
+    _setGreen(self, RARRAY_AREF(data,1));
+    _setBlue(self, RARRAY_AREF(data,2));
+    _setAlpha(self, RARRAY_AREF(data,3));
+    return Qnil;
+}
+
+struct equal_obj {
+	wxColor* self;
+	VALUE other;
+};
+
+VALUE _equal_block(equal_obj *obj)
+{
+	return wrap(*obj->self == unwrap<wxColor>(obj->other));
+}
+
+VALUE _equal_rescue(VALUE val)
+{
+	return Qfalse;
+}
+
+/*
+ * call-seq:
+ *   == color -> bool
+ *
+ * compares two colors.
+ *
+ *
+ */
+DLL_LOCAL VALUE _equal(VALUE self, VALUE other)
+{
+	equal_obj obj;
+	obj.self = _self;
+	obj.other = other;
+
+	return rb_rescue(
+		RUBY_METHOD_FUNC(_equal_block),(VALUE)&obj,
+		RUBY_METHOD_FUNC(_equal_rescue),Qnil
+	);
+}
+
+
+
+}
+}
+
+
+/*
+ * Document-class: WX::Color
+ *
+ * This class represents an Color.
+*/
+
+/* Document-attr: red
+ * returns the red value of Color.
+ */
+/* Document-attr: blue
+ * returns the blue value of Color.
+ */
+/* Document-attr: green
+ * returns the green value of Color.
+ */
+/* Document-attr: alpha
+ * returns the alpha value of Color.
+ */
+
+/* Document-const: BLACK
+ * predefined Color constant.
+ */
+/* Document-const: BLUE
+ * predefined Color constant.
+ */
+/* Document-const: CYAN
+ * predefined Color constant.
+ */
+/* Document-const: GREEN
+ * predefined Color constant.
+ */
+/* Document-const: YELLOW
+ * predefined Color constant.
+ */
+/* Document-const: LIGHT_GREY
+ * predefined Color constant.
+ */
+/* Document-const: RED
+ * predefined Color constant.
+ */
+/* Document-const: WHITE
+ * predefined Color constant.
+ */
+DLL_LOCAL void Init_WXColor(VALUE rb_mWX)
+{
+	using namespace RubyWX::Color;
+	rb_cWXColor = rb_define_class_under(rb_mWX,"Color",rb_cObject);
+
+#if 0
+	rb_define_attr(rb_cWXColor,"red",1,1);
+	rb_define_attr(rb_cWXColor,"green",1,1);
+	rb_define_attr(rb_cWXColor,"blue",1,1);
+	rb_define_attr(rb_cWXColor,"alpha",1,1);
+
+	rb_define_const(rb_cWXColor,"BLACK",wrap(wxBLACK));
+	rb_define_const(rb_cWXColor,"BLUE",wrap(wxBLUE));
+	rb_define_const(rb_cWXColor,"CYAN",wrap(wxCYAN));
+	rb_define_const(rb_cWXColor,"GREEN",wrap(wxGREEN));
+	rb_define_const(rb_cWXColor,"YELLOW",wrap(wxYELLOW));
+	rb_define_const(rb_cWXColor,"LIGHT_GREY",wrap(wxLIGHT_GREY));
+	rb_define_const(rb_cWXColor,"RED",wrap(wxRED));
+	rb_define_const(rb_cWXColor,"WHITE",wrap(wxWHITE));
+#endif
+
+	rb_define_alloc_func(rb_cWXColor,_alloc);
+
+	rb_define_method(rb_cWXColor,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+	rb_define_private_method(rb_cWXColor,"initialize_copy",RUBY_METHOD_FUNC(_initialize_copy),1);
+
+
+	rb_define_attr_method(rb_cWXColor,"red",_getRed,_setRed);
+	rb_define_attr_method(rb_cWXColor,"green",_getGreen,_setGreen);
+	rb_define_attr_method(rb_cWXColor,"blue",_getBlue,_setBlue);
+	rb_define_attr_method(rb_cWXColor,"alpha",_getAlpha,_setAlpha);
+
+	rb_define_method(rb_cWXColor,"to_s",RUBY_METHOD_FUNC(_tos),0);
+	rb_define_method(rb_cWXColor,"name",RUBY_METHOD_FUNC(_name),0);
+	rb_define_method(rb_cWXColor,"inspect",RUBY_METHOD_FUNC(_inspect),0);
+
+	rb_define_method(rb_cWXColor,"marshal_dump",RUBY_METHOD_FUNC(_marshal_dump),0);
+	rb_define_method(rb_cWXColor,"marshal_load",RUBY_METHOD_FUNC(_marshal_load),1);
+
+	rb_define_method(rb_cWXColor,"==",RUBY_METHOD_FUNC(_equal),1);
+
+	rwxID_red = rb_intern("red");
+	rwxID_blue = rb_intern("blue");
+	rwxID_green = rb_intern("green");
+	rwxID_alpha = rb_intern("alpha");
+
+	registerType<wxColor>(rb_cWXColor, true);
+}