rwx 0.0.1.dev

data/ext/wxBookCtrl.hpp

@@ -0,0 +1,22 @@
+/*
+ * wxBookCtrl.hpp
+ *
+ *  Created on: 27.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXBOOKCTRL_HPP_
+#define WXBOOKCTRL_HPP_
+
+#include "wxEvtHandler.hpp"
+
+extern VALUE rb_cWXBookCtrlBase,rb_cWXBookCtrlEvent;
+
+void Init_WXBookCtrl(VALUE rb_mWX);
+
+#if wxUSE_BOOKCTRL
+template <>
+wxBookCtrlBase* unwrap<wxBookCtrlBase*>(const VALUE &arg);
+#endif
+
+#endif /* WXBOOKCTRL_HPP_ */

data/ext/wxBoxSizer.cpp

@@ -0,0 +1,60 @@
+/*
+ * wxBoxSizer.cpp
+ *
+ *  Created on: 27.03.2012
+ *      Author: hanmac
+ */
+
+#include "wxSizer.hpp"
+
+#define _self unwrap<wxBoxSizer*>(self)
+
+VALUE rb_cWXBoxSizer;
+
+namespace RubyWX {
+namespace BoxSizer {
+
+macro_attr_enum(Orientation,wxOrientation)
+
+singlereturn(IsVertical)
+
+DLL_LOCAL VALUE _alloc(VALUE self)
+{
+	return wrapTypedPtr(new wxBoxSizer(wxHORIZONTAL),self);
+}
+
+
+DLL_LOCAL VALUE _initialize(int argc,VALUE *argv,VALUE self)
+{
+	VALUE orient;
+	rb_scan_args(argc, argv, "01",&orient);
+	if(!NIL_P(orient))
+		_setOrientation(self,orient);
+	return self;
+}
+
+
+}
+}
+
+
+
+DLL_LOCAL void Init_WXBoxSizer(VALUE rb_mWX)
+{
+	using namespace RubyWX::BoxSizer;
+	rb_cWXBoxSizer = rb_define_class_under(rb_mWX,"BoxSizer",rb_cWXSizer);
+	rb_define_alloc_func(rb_cWXBoxSizer,_alloc);
+
+	rb_define_attr_method(rb_cWXBoxSizer,"orientation",_getOrientation,_setOrientation);
+
+	rb_define_method(rb_cWXBoxSizer,"vertical?",RUBY_METHOD_FUNC(_IsVertical),0);
+
+	registerInfo<wxBoxSizer>(rb_cWXBoxSizer);
+
+	registerEnum<wxOrientation>("wxOrientation")
+			->add(wxHORIZONTAL, "horizontal")
+			->add(wxVERTICAL, "vertical")
+			->add(wxBOTH, "both");
+
+
+}

data/ext/wxBoxSizer.hpp

@@ -0,0 +1,17 @@
+/*
+ * wxBoxSizer.hpp
+ *
+ *  Created on: 27.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXBOXSIZER_HPP_
+#define WXBOXSIZER_HPP_
+
+#include "main.hpp"
+
+extern VALUE rb_cWXBoxSizer;
+
+void Init_WXBoxSizer(VALUE rb_mWX);
+
+#endif /* WXBOXSIZER_HPP_ */

data/ext/wxBrush.cpp

@@ -0,0 +1,281 @@
+/*
+ * wxBrush.cpp
+ *
+ *  Created on: 21.04.2012
+ *      Author: hanmac
+ */
+
+#include "wxBrush.hpp"
+#include "wxColor.hpp"
+#include "wxBitmap.hpp"
+
+#define _self unwrap<wxBrush*>(self)
+
+VALUE rb_cWXBrush;
+
+typedef std::map<wxBrush*,VALUE> brushlisttype;
+brushlisttype brushlistholder;
+
+template <>
+wxBrush unwrap< wxBrush >(const VALUE &vbrush)
+{
+	return NIL_P(vbrush) ? wxNullBrush : *unwrap< wxBrush* >(vbrush);
+}
+
+namespace RubyWX {
+namespace Brush {
+DLL_LOCAL VALUE _alloc(VALUE self) {
+	return wrap(new wxBrush(*wxBLACK));
+}
+
+macro_attr(Colour,wxColour)
+macro_attr_enum(Style,wxBrushStyle)
+macro_attr(Stipple,wxBitmap)
+
+singlereturn(IsHatch)
+
+
+void define_const()
+{
+	if(rb_const_defined(rb_cWXBrush,rb_intern("BLACK")))
+		return;
+
+	rb_define_const(rb_cWXBrush,"BLACK",wrap(wxBLACK_BRUSH));
+	rb_define_const(rb_cWXBrush,"BLUE",wrap(wxBLUE_BRUSH));
+	rb_define_const(rb_cWXBrush,"CYAN",wrap(wxCYAN_BRUSH));
+	rb_define_const(rb_cWXBrush,"GREEN",wrap(wxGREEN_BRUSH));
+	rb_define_const(rb_cWXBrush,"YELLOW",wrap(wxYELLOW_BRUSH));
+	rb_define_const(rb_cWXBrush,"GREY",wrap(wxGREY_BRUSH));
+	rb_define_const(rb_cWXBrush,"LIGHT_GREY",wrap(wxLIGHT_GREY_BRUSH));
+	rb_define_const(rb_cWXBrush,"MEDIUM_GREY",wrap(wxMEDIUM_GREY_BRUSH));
+	rb_define_const(rb_cWXBrush,"RED",wrap(wxRED_BRUSH));
+	rb_define_const(rb_cWXBrush,"TRANSPARENT",wrap(wxTRANSPARENT_BRUSH));
+	rb_define_const(rb_cWXBrush,"WHITE",wrap(wxWHITE_BRUSH));
+}
+
+/*
+ * call-seq:
+ *   Brush.new(color[,style])
+ *
+ * creates a new Brush Object.
+*/
+DLL_LOCAL VALUE _initialize(int argc,VALUE *argv,VALUE self)
+{
+	VALUE color,style;
+	rb_scan_args(argc, argv, "11",&color,&style);
+	_setColour(self,color);
+	if(!NIL_P(style))
+		_setStyle(self,style);
+	return self;
+}
+
+/*
+*/
+DLL_LOCAL VALUE _initialize_copy(VALUE self, VALUE other)
+{
+	VALUE result = rb_call_super(1,&other);
+	_setColour(self,_getColour(other));
+	_setStyle(self,_getStyle(other));
+	_setStipple(self,_getStipple(other));
+	return result;
+}
+
+
+/*
+ * 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[3];
+    ptr[0] = _getColour(self);
+    ptr[1] = _getStyle(self);
+    ptr[2] = _getStipple(self);
+    return rb_ary_new4(3, 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)
+{
+    _setColour(self, RARRAY_AREF(data,0));
+    _setStyle(self, RARRAY_AREF(data,1));
+    _setStipple(self, RARRAY_AREF(data,2));
+    return Qnil;
+}
+
+
+/*
+ * call-seq:
+ *   == brush -> bool
+ *
+ * compares two brush.
+ *
+ *
+ */
+DLL_LOCAL VALUE _equal(VALUE self, VALUE other)
+{
+	return wrap((*_self) == unwrap<wxBrush>(other));
+}
+
+
+DLL_LOCAL VALUE _class_get(int argc,VALUE *argv,VALUE self)
+{
+
+	VALUE color,style;
+	rb_scan_args(argc, argv, "11",&color,&style);
+	//TODO add refcounting
+	wxBrush *brush = wxTheBrushList->FindOrCreateBrush(
+		unwrap<wxColor>(color),
+		NIL_P(style) ? wxBRUSHSTYLE_SOLID : unwrapenum<wxBrushStyle>(style)
+	);
+
+	if(!brush || !brush->IsOk())
+		return Qnil;
+
+	//look in the PenList holder is brush was already wrapped
+	brushlisttype::iterator it = brushlistholder.find(brush);
+	if(it != brushlistholder.end()) {
+		return it->second;
+	} else {
+		//wrap wxBrush pointer to ruby object
+		VALUE result = wrap(brush);
+
+		//BrushList objects should not be changed
+		rb_obj_freeze(result);
+		//Prevent BrushList objects from been deleted
+		rwx_refobject(result);
+		//add wrapped brush to the BrushList holder to find it again
+		brushlistholder[brush] = result;
+		return result;
+	}
+}
+
+}
+}
+
+/*
+ * Document-class: WX::Brush
+ *
+ * This class represents an Brush.
+*/
+
+
+/* Document-attr: color
+ * returns the color of the Brush. WX::Color
+ */
+/* Document-attr: style
+ * returns the style of the Brush. Symbol
+ */
+/* Document-attr: stipple
+ * returns the stipple of the Brush. WX::Bitmap
+ */
+
+/* Document-const: BLACK
+ * predefined Brush constant.
+ */
+/* Document-const: BLUE
+ * predefined Brush constant.
+ */
+/* Document-const: CYAN
+ * predefined Brush constant.
+ */
+/* Document-const: GREEN
+ * predefined Brush constant.
+ */
+/* Document-const: YELLOW
+ * predefined Brush constant.
+ */
+/* Document-const: GREY
+ * predefined Brush constant.
+ */
+/* Document-const: LIGHT_GREY
+ * predefined Brush constant.
+ */
+/* Document-const: MEDIUM_GREY
+ * predefined Brush constant.
+ */
+/* Document-const: RED
+ * predefined Brush constant.
+ */
+/* Document-const: TRANSPARENT
+ * predefined Brush constant.
+ */
+/* Document-const: WHITE
+ * predefined Brush constant.
+ */
+
+DLL_LOCAL void Init_WXBrush(VALUE rb_mWX)
+{
+#if 0
+
+	rb_define_attr(rb_cWXBrush,"color",1,1);
+	rb_define_attr(rb_cWXBrush,"style",1,1);
+	rb_define_attr(rb_cWXBrush,"stipple",1,1);
+
+	//need to
+	rb_define_const(rb_cWXBrush,"BLACK",wrap(wxBLACK_BRUSH));
+	rb_define_const(rb_cWXBrush,"BLUE",wrap(wxBLUE_BRUSH));
+	rb_define_const(rb_cWXBrush,"CYAN",wrap(wxCYAN_BRUSH));
+	rb_define_const(rb_cWXBrush,"GREEN",wrap(wxGREEN_BRUSH));
+	rb_define_const(rb_cWXBrush,"YELLOW",wrap(wxYELLOW_BRUSH));
+	rb_define_const(rb_cWXBrush,"GREY",wrap(wxGREY_BRUSH));
+	rb_define_const(rb_cWXBrush,"LIGHT_GREY",wrap(wxLIGHT_GREY_BRUSH));
+	rb_define_const(rb_cWXBrush,"MEDIUM_GREY",wrap(wxMEDIUM_GREY_BRUSH));
+	rb_define_const(rb_cWXBrush,"RED",wrap(wxRED_BRUSH));
+	rb_define_const(rb_cWXBrush,"TRANSPARENT",wrap(wxTRANSPARENT_BRUSH));
+	rb_define_const(rb_cWXBrush,"WHITE",wrap(wxWHITE_BRUSH));
+#endif
+
+	using namespace RubyWX::Brush;
+	rb_cWXBrush = rb_define_class_under(rb_mWX,"Brush",rb_cObject);
+	rb_define_alloc_func(rb_cWXBrush,_alloc);
+
+	rb_define_method(rb_cWXBrush,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+	rb_define_private_method(rb_cWXBrush,"initialize_copy",RUBY_METHOD_FUNC(_initialize_copy),1);
+
+	rb_define_attr_method(rb_cWXBrush,"color",_getColour,_setColour);
+	rb_define_attr_method(rb_cWXBrush,"style",_getStyle,_setStyle);
+	rb_define_attr_method(rb_cWXBrush,"stipple",_getStipple,_setStipple);
+
+	rb_define_method(rb_cWXBrush,"hatch?",RUBY_METHOD_FUNC(_IsHatch),0);
+
+	rb_define_method(rb_cWXBrush,"marshal_dump",RUBY_METHOD_FUNC(_marshal_dump),0);
+	rb_define_method(rb_cWXBrush,"marshal_load",RUBY_METHOD_FUNC(_marshal_load),1);
+
+	rb_define_method(rb_cWXBrush,"==",RUBY_METHOD_FUNC(_equal),1);
+
+	//
+//	rb_define_method(rb_cWXBrush,"to_s",RUBY_METHOD_FUNC(_tos),0);
+//	rb_define_method(rb_cWXBrush,"inspect",RUBY_METHOD_FUNC(_inspect),0);
+
+	registerInfo<wxBrush>(rb_cWXBrush);
+
+	registerEnum<wxBrushStyle>("WX::BrushStyle",wxBRUSHSTYLE_TRANSPARENT)
+		->add(wxBRUSHSTYLE_SOLID,"solid")
+		->add(wxBRUSHSTYLE_TRANSPARENT,"transparent")
+		->add(wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE,"stipple_mask_opaque")
+		->add(wxBRUSHSTYLE_STIPPLE_MASK,"stipple_mask")
+		->add(wxBRUSHSTYLE_STIPPLE,"stipple")
+		->add(wxBRUSHSTYLE_BDIAGONAL_HATCH,"bdiagonal_hatch")
+		->add(wxBRUSHSTYLE_CROSSDIAG_HATCH,"crossdiag_hatch")
+		->add(wxBRUSHSTYLE_FDIAGONAL_HATCH,"fdiagonal_hatch")
+		->add(wxBRUSHSTYLE_CROSS_HATCH,"cross_hatch")
+		->add(wxBRUSHSTYLE_HORIZONTAL_HATCH,"horizontal_hatch")
+		->add(wxBRUSHSTYLE_VERTICAL_HATCH,"vertical_hatch");
+
+}
+
+
+
+

data/ext/wxBrush.hpp

@@ -0,0 +1,28 @@
+/*
+ * wxBrush.hpp
+ *
+ *  Created on: 21.04.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXBRUSH_HPP_
+#define WXBRUSH_HPP_
+
+
+#include "main.hpp"
+
+extern VALUE rb_cWXBrush;
+void Init_WXBrush(VALUE rb_mWX);
+
+template <>
+wxBrush unwrap< wxBrush >(const VALUE &vbrush);
+
+namespace RubyWX {
+namespace Brush {
+
+void define_const();
+
+}
+}
+
+#endif /* WXBRUSH_HPP_ */

data/ext/wxButton.cpp

@@ -0,0 +1,85 @@
+/*
+ * wxButton.cpp
+ *
+ *  Created on: 20.03.2012
+ *      Author: hanmac
+ */
+
+#include "wxButton.hpp"
+
+VALUE rb_cWXButton;
+#if wxUSE_BUTTON
+#define _self unwrap<wxButton*>(self)
+
+namespace RubyWX {
+namespace Button {
+
+macro_attr(AuthNeeded,bool)
+
+APP_PROTECT(wxButton)
+
+/*
+ * call-seq:
+ *   Button.new(parent, name, [options])
+ *   Button.new(parent, [options])
+ *
+ * creates a new Button 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);
+		wxString label(wxEmptyString);
+
+		if(rb_obj_is_kind_of(hash,rb_cHash)) {
+			set_hash_option(hash,"id",id,unwrapID);
+			set_hash_option(hash,"label",label);
+		}
+
+		_self->Create(unwrap<wxWindow*>(parent),id,label);
+		
+	}
+
+	rb_call_super(argc,argv);
+
+	return self;
+}
+
+}
+}
+
+#endif
+
+DLL_LOCAL void Init_WXButton(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_cWXAnyButton = rb_define_class_under(rb_mWX,"AnyButton",rb_cWXControl);
+	rb_define_attr(rb_cWXButton,"auth_needed",1,1);
+#endif
+
+#if wxUSE_BUTTON
+	using namespace RubyWX::Button;
+	rb_cWXButton = rb_define_class_under(rb_mWX,"Button",rb_cWXAnyButton);
+	rb_define_alloc_func(rb_cWXButton,_alloc);
+
+	rb_define_method(rb_cWXButton,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_attr_method(rb_cWXButton,"auth_needed",_getAuthNeeded,_setAuthNeeded);
+
+	registerInfo<wxButton>(rb_cWXButton);
+
+	registerEventType<wxCommandEvent>("button",wxEVT_BUTTON);
+
+#endif
+}