rwx 0.0.1.dev

data/ext/wxRearrangeList.hpp

@@ -0,0 +1,20 @@
+/*
+ * wxRearrangeList.hpp
+ *
+ *  Created on: 14.03.2013
+ *      Author: hanmac
+ */
+
+#ifndef WXREARRANGELIST_HPP_
+#define WXREARRANGELIST_HPP_
+
+#include "wxCheckListBox.hpp"
+
+extern VALUE rb_cWXRearrangeList;
+
+void Init_WXRearrangeList(VALUE rb_mWX);
+#if wxUSE_REARRANGECTRL
+#include <wx/rearrangectrl.h>
+#endif
+
+#endif /* WXREARRANGELIST_HPP_ */

data/ext/wxRect.cpp

@@ -0,0 +1,281 @@
+/*
+ * wxRect.cpp
+ *
+ *  Created on: 23.03.2012
+ *      Author: hanmac
+ */
+
+#include "wxRect.hpp"
+#include "wxPoint.hpp"
+#include "wxSize.hpp"
+
+VALUE rb_cWXRect;
+
+#define _self unwrap<wxRect*>(self)
+
+template <>
+VALUE wrap< wxRect >(wxRect *rect )
+{
+	return wrapTypedPtr(rect, rb_cWXRect);
+}
+
+template <>
+bool is_wrapable< wxRect >(const VALUE &vrect)
+{
+	if (rb_obj_is_kind_of(vrect, rb_cWXRect)){
+		return true;
+	}else if(rb_respond_to(vrect,rwxID_x) &&
+		rb_respond_to(vrect,rwxID_y) &&
+		rb_respond_to(vrect,rwxID_width) &&
+		rb_respond_to(vrect,rwxID_height)){
+		return true;
+	}else
+		return false;
+}
+
+template <>
+wxRect* unwrap< wxRect* >(const VALUE &vrect)
+{
+	if(!rb_obj_is_kind_of(vrect, rb_cWXRect) &&
+		rb_respond_to(vrect,rwxID_x) &&
+		rb_respond_to(vrect,rwxID_y) &&
+		rb_respond_to(vrect,rwxID_width) &&
+		rb_respond_to(vrect,rwxID_height)){
+		wxRect *size = new wxRect;
+		size->SetX(NUM2INT(rb_funcall(vrect,rwxID_x,0)));
+		size->SetY(NUM2INT(rb_funcall(vrect,rwxID_y,0)));
+
+		size->SetWidth(NUM2INT(rb_funcall(vrect,rwxID_width,0)));
+		size->SetHeight(NUM2INT(rb_funcall(vrect,rwxID_height,0)));
+		return size;
+	}else{
+		return unwrapTypedPtr<wxRect>(vrect, rb_cWXRect);
+	}
+}
+
+template <>
+wxRect unwrap< wxRect >(const VALUE &vsize)
+{
+	return *unwrap<wxRect*>(vsize);
+}
+
+
+namespace RubyWX {
+namespace Rect {
+
+macro_attr(X,int)
+macro_attr(Y,int)
+macro_attr(Width,int)
+macro_attr(Height,int)
+
+macro_attr(Position,wxPoint)
+macro_attr(Size,wxSize)
+
+macro_attr(Left,int)
+macro_attr(Top,int)
+macro_attr(Bottom,int)
+macro_attr(Right,int)
+
+macro_attr(TopLeft,wxPoint)
+macro_attr(TopRight,wxPoint)
+macro_attr(BottomLeft,wxPoint)
+macro_attr(BottomRight,wxPoint)
+
+DLL_LOCAL VALUE _alloc(VALUE self)
+{
+	return wrap(new wxRect());
+}
+
+DLL_LOCAL VALUE _initialize(VALUE self,VALUE x,VALUE y,VALUE width,VALUE height)
+{
+	_setX(self,x);
+	_setY(self,y);
+	_setWidth(self,width);
+	_setHeight(self,height);
+	return self;
+}
+
+/*
+*/
+DLL_LOCAL VALUE _initialize_copy(VALUE self, VALUE other)
+{
+	VALUE result = rb_call_super(1,&other);
+	_setX(self,_getX(other));
+	_setY(self,_getY(other));
+	_setWidth(self,_getWidth(other));
+	_setHeight(self,_getHeight(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(_getX(self)),
+		FIX2INT(_getY(self)),
+		FIX2INT(_getWidth(self)),
+		FIX2INT(_getHeight(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] = _getX(self);
+    ptr[1] = _getY(self);
+    ptr[2] = _getWidth(self);
+    ptr[3] = _getHeight(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)
+{
+	_setX(self, RARRAY_AREF(data,0));
+    _setY(self, RARRAY_AREF(data,1));
+    _setWidth(self, RARRAY_AREF(data,2));
+    _setHeight(self, RARRAY_AREF(data,3));
+    return Qnil;
+}
+
+
+}
+}
+
+/*
+ * Document-class: WX::Rect
+ *
+ * This class represents an Rect.
+ */
+
+/* Document-attr: x
+ * returns the x value of Rect. Integer
+ */
+/* Document-attr: y
+ * returns the y value of Rect. Integer
+ */
+/* Document-attr: width
+ * returns the width value of Rect. Integer
+ */
+/* Document-attr: height
+ * returns the height value of Rect. Integer
+ */
+
+/* Document-attr: position
+ * returns the position of Rect. WX::Point
+ */
+/* Document-attr: size
+ * returns the size of Rect. WX::Size
+ */
+
+/* Document-attr: left
+ * returns the left of Rect. Integer
+ */
+/* Document-attr: top
+ * returns the top of Rect. Integer
+ */
+/* Document-attr: bottom
+ * returns the bottom of Rect. Integer
+ */
+/* Document-attr: right
+ * returns the right of Rect. Integer
+ */
+
+/* Document-attr: top_left
+ * returns the top left of Rect. WX::Point
+ */
+/* Document-attr: top_right
+ * returns the top right of Rect. WX::Point
+ */
+/* Document-attr: bottom_left
+ * returns the bottom left of Rect. WX::Point
+ */
+/* Document-attr: bottom_right
+ * returns the bottom right of Rect. WX::Point
+ */
+
+DLL_LOCAL void Init_WXRect(VALUE rb_mWX)
+{
+
+#if 0
+	rb_mWX = rb_define_module("WX");
+
+	rb_define_attr(rb_cWXRect,"x",1,1);
+	rb_define_attr(rb_cWXRect,"y",1,1);
+	rb_define_attr(rb_cWXRect,"width",1,1);
+	rb_define_attr(rb_cWXRect,"height",1,1);
+
+	rb_define_attr(rb_cWXRect,"position",1,1);
+	rb_define_attr(rb_cWXRect,"size",1,1);
+
+	rb_define_attr(rb_cWXRect,"left",1,1);
+	rb_define_attr(rb_cWXRect,"top",1,1);
+	rb_define_attr(rb_cWXRect,"bottom",1,1);
+	rb_define_attr(rb_cWXRect,"right",1,1);
+
+	rb_define_attr(rb_cWXRect,"top_left",1,1);
+	rb_define_attr(rb_cWXRect,"top_right",1,1);
+	rb_define_attr(rb_cWXRect,"bottom_left",1,1);
+	rb_define_attr(rb_cWXRect,"bottom_right",1,1);
+
+#endif
+
+	using namespace RubyWX::Rect;
+	rb_cWXRect = rb_define_class_under(rb_mWX,"Rect",rb_cObject);
+
+	rb_define_alloc_func(rb_cWXRect,_alloc);
+
+	rb_define_method(rb_cWXRect,"initialize",RUBY_METHOD_FUNC(_initialize),4);
+	rb_define_private_method(rb_cWXRect,"initialize_copy",RUBY_METHOD_FUNC(_initialize_copy),1);
+
+	rb_define_attr_method(rb_cWXRect,"x",_getX,_setX);
+	rb_define_attr_method(rb_cWXRect,"y",_getY,_setY);
+
+	rb_define_attr_method(rb_cWXRect,"width",_getWidth,_setWidth);
+	rb_define_attr_method(rb_cWXRect,"height",_getHeight,_setHeight);
+
+	rb_define_attr_method(rb_cWXRect,"position",_getPosition,_setPosition);
+	rb_define_attr_method(rb_cWXRect,"size",_getSize,_setSize);
+
+	rb_define_attr_method(rb_cWXRect,"left",_getLeft,_setLeft);
+	rb_define_attr_method(rb_cWXRect,"top",_getTop,_setTop);
+	rb_define_attr_method(rb_cWXRect,"bottom",_getBottom,_setBottom);
+	rb_define_attr_method(rb_cWXRect,"right",_getRight,_setRight);
+
+	rb_define_attr_method(rb_cWXRect,"top_left",_getTopLeft,_setTopLeft);
+	rb_define_attr_method(rb_cWXRect,"top_right",_getTopRight,_setTopRight);
+	rb_define_attr_method(rb_cWXRect,"bottom_left",_getBottomLeft,_setBottomLeft);
+	rb_define_attr_method(rb_cWXRect,"bottom_right",_getBottomRight,_setBottomRight);
+
+	rb_define_method(rb_cWXRect,"inspect",RUBY_METHOD_FUNC(_inspect),0);
+
+	rb_define_method(rb_cWXRect,"marshal_dump",RUBY_METHOD_FUNC(_marshal_dump),0);
+	rb_define_method(rb_cWXRect,"marshal_load",RUBY_METHOD_FUNC(_marshal_load),1);
+
+	registerType<wxRect>(rb_cWXRect, true);
+}
+
+
+

data/ext/wxRect.hpp

@@ -0,0 +1,29 @@
+/*
+ * wxRect.hpp
+ *
+ *  Created on: 23.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXRECT_HPP_
+#define WXRECT_HPP_
+
+#include "main.hpp"
+
+extern VALUE rb_cWXRect;
+void Init_WXRect(VALUE rb_mWX);
+
+
+template <>
+VALUE wrap< wxRect >(wxRect *size );
+
+template <>
+bool is_wrapable< wxRect >(const VALUE &vsize);
+
+template <>
+wxRect* unwrap< wxRect* >(const VALUE &vsize);
+
+template <>
+wxRect unwrap< wxRect >(const VALUE &vsize);
+
+#endif /* WXRECT_HPP_ */

data/ext/wxRichMessageDialog.cpp

@@ -0,0 +1,91 @@
+/*
+ * wxMessageDialog.cpp
+ *
+ *  Created on: 22.06.2014
+ *      Author: hanmac
+ */
+
+
+#include "wxRichMessageDialog.hpp"
+
+VALUE rb_cWXRichMessageDialog;
+
+#if wxUSE_RICHMSGDLG
+#define _self unwrap<wxRichMessageDialog*>(self)
+
+namespace RubyWX {
+namespace RichMessageDialog {
+
+#ifdef HAVE_WXRICHMESSAGEDIALOG
+APP_PROTECT(wxRichMessageDialog)
+#else
+APP_PROTECT_NULL
+#endif
+
+DLL_LOCAL VALUE _initialize(int argc,VALUE *argv,VALUE self)
+{
+	VALUE parent,name,hash;
+	rb_scan_args(argc, argv, "11:",&parent,&name,&hash);
+
+	wxString message;
+	wxString caption(wxMessageBoxCaptionStr);
+	int style(wxOK|wxCENTRE);
+
+#ifdef HAVE_WXRICHMESSAGEDIALOG
+	if(!_created && rb_obj_is_kind_of(name,rb_cString)) {
+
+		if(rb_obj_is_kind_of(hash,rb_cHash)) {
+			set_hash_option(hash,"message",message);
+			set_hash_option(hash,"caption",caption);
+			set_hash_option(hash,"style",style);
+		}
+
+		_self->Create(
+			unwrap<wxWindow*>(parent),message,caption,style
+		);
+
+	}
+#else
+	if(rb_obj_is_kind_of(hash,rb_cHash)) {
+		set_hash_option(hash,"message",message);
+		set_hash_option(hash,"caption",caption);
+		set_hash_option(hash,"style",style);
+	}
+
+	RTYPEDDATA_DATA(self) = new wxRichMessageDialog(
+		unwrap<wxWindow*>(parent),message,caption,style
+	);
+
+#endif
+
+	rb_call_super(argc,argv);
+	return self;
+}
+
+
+}
+}
+#endif
+DLL_LOCAL void Init_WXRichMessageDialog(VALUE rb_mWX)
+{
+
+#if 0
+	rb_mWX = rb_define_module("WX");
+	rb_cWXWindow = rb_define_class_under(rb_mWX,"Window",rb_cObject);
+
+	rb_cWXTopLevel = rb_define_class_under(rb_mWX,"TopLevel",rb_cWXWindow);
+	rb_cWXDialog = rb_define_class_under(rb_mWX,"Dialog",rb_cWXTopLevel);
+	rb_cWXMessageDialogBase = rb_define_class_under(rb_mWX,"MessageDialogBase",rb_cWXDialog);
+#endif
+
+#if wxUSE_RICHMSGDLG
+	using namespace RubyWX::RichMessageDialog;
+	rb_cWXRichMessageDialog = rb_define_class_under(rb_mWX,"RichMessageDialog",rb_cWXMessageDialogBase);
+	rb_define_alloc_func(rb_cWXRichMessageDialog,_alloc);
+
+	rb_define_method(rb_cWXRichMessageDialog,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	registerInfo<wxRichMessageDialog>(rb_cWXRichMessageDialog);
+#endif
+
+}

data/ext/wxRichMessageDialog.hpp

@@ -0,0 +1,21 @@
+/*
+ * wxMessageDialog.hpp
+ *
+ *  Created on: 25.11.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXRICHMESSAGEDIALOG_HPP_
+#define WXMESSAGEDIALOG_HPP_
+
+#include "wxMessageDialogBase.hpp"
+
+extern VALUE rb_cWXRichMessageDialog;
+
+void Init_WXRichMessageDialog(VALUE rb_mWX);
+
+#if wxUSE_RICHMSGDLG
+#include <wx/richmsgdlg.h>
+#endif
+
+#endif /* WXRICHMESSAGEDIALOG_HPP_ */

data/ext/wxRichTextAttr.cpp

@@ -0,0 +1,69 @@
+/*
+ * wxTextAttr.cpp
+ *
+ *  Created on: 27.04.2012
+ *      Author: hanmac
+ */
+
+#include "wxTextAttr.hpp"
+#include "wxRichTextAttr.hpp"
+
+VALUE rb_cWXRichTextAttr;
+
+#if wxUSE_RICHTEXT
+
+//find better way?
+template <>
+VALUE wrap< wxRichTextAttr >(wxRichTextAttr *attr )
+{
+	return wrapTypedPtr(attr, rb_cWXRichTextAttr);
+}
+
+template <>
+wxRichTextAttr unwrap< wxRichTextAttr >(const VALUE &vattr)
+{
+	return *unwrapTypedPtr<wxRichTextAttr>(vattr,rb_cWXTextAttr);
+}
+
+#define _self unwrap<wxRichTextAttr*>(self)
+
+
+
+namespace RubyWX {
+namespace RichTextAttr {
+
+APP_PROTECT(wxRichTextAttr)
+
+/*
+*/
+DLL_LOCAL VALUE _initialize_copy(VALUE self, VALUE other)
+{
+	VALUE result = rb_call_super(1,&other);
+	_self->Copy(unwrap<wxRichTextAttr>(other));
+	return result;
+}
+
+}
+}
+#endif
+
+
+DLL_LOCAL void Init_WXRichTextAttr(VALUE rb_mWX)
+{
+#if 0
+	rb_cWXTextAttr = rb_define_class_under(rb_mWX,"TextAttr",rb_cObject);
+
+#endif
+
+#if wxUSE_RICHTEXT
+	using namespace RubyWX::RichTextAttr;
+	rb_cWXRichTextAttr = rb_define_class_under(rb_mWX,"RichTextAttr",rb_cWXTextAttr);
+	rb_define_alloc_func(rb_cWXRichTextAttr,_alloc);
+
+	rb_define_private_method(rb_cWXRichTextAttr,"initialize_copy",RUBY_METHOD_FUNC(_initialize_copy),1);
+
+	registerType<wxRichTextAttr>(rb_cWXRichTextAttr);
+
+#endif
+
+}