rwx 0.0.1.dev

data/ext/wxSearchCtrl.hpp

@@ -0,0 +1,21 @@
+/*
+ * wxSearchCtrl.hpp
+ *
+ *  Created on: 14.05.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXSEARCHCTRL_HPP_
+#define WXSEARCHCTRL_HPP_
+
+#include "wxControl.hpp"
+
+extern VALUE rb_cWXSearchCtrl;
+
+void Init_WXSearchCtrl(VALUE rb_mWX);
+
+#if wxUSE_SEARCHCTRL
+#include <wx/srchctrl.h>
+#endif
+
+#endif /* WXSEARCHCTRL_HPP_ */

data/ext/wxSimpleBook.cpp

@@ -0,0 +1,89 @@
+/*
+ * wxSimpleBook.cpp
+ *
+ *  Created on: 30.03.2012
+ *      Author: hanmac
+ */
+
+#include "wxSimpleBook.hpp"
+#include "wxBookCtrl.hpp"
+
+VALUE rb_cWXSimplebook;
+
+#if wxUSE_BOOKCTRL
+#define _self unwrap<wxSimplebook*>(self)
+
+namespace RubyWX {
+namespace Simplebook {
+
+APP_PROTECT(wxSimplebook)
+
+/*
+ * call-seq:
+ *   SimpleBookCtrl.new(parent, name, [options])
+ *   SimpleBookCtrl.new(parent, [options])
+ *
+ * creates a new SimpleBookCtrl widget.
+ * ===Arguments
+ * * parent of this window or nil
+ *
+ * *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(0);
+
+		if(rb_obj_is_kind_of(hash,rb_cHash))
+		{
+			set_hash_option(hash,"id",id,unwrapID);
+			set_hash_option(hash,"style",style);
+		}
+
+		_self->Create(unwrap<wxWindow*>(parent),id,wxDefaultPosition,wxDefaultSize,style);
+		
+	}
+
+	rb_call_super(argc,argv);
+
+	return self;
+}
+
+}
+}
+#endif
+DLL_LOCAL void Init_WXSimpleBookCtrl(VALUE rb_mWX)
+{
+#if 0
+	rb_mWX = rb_define_module("WX");
+	rb_mWXEvtHandler = rb_define_module_under(rb_mWX,"EvtHandler");
+
+	rb_cWXWindow = rb_define_class_under(rb_mWX,"Window",rb_cObject);
+	rb_cWXControl = rb_define_class_under(rb_mWX,"Control",rb_cWXWindow);
+	rb_cWXBookCtrlBase = rb_define_class_under(rb_mWX,"BookCtrl",rb_cWXControl);
+#endif
+
+#if wxUSE_BOOKCTRL
+	using namespace RubyWX::Simplebook;
+	rb_cWXSimplebook = rb_define_class_under(rb_mWX,"SimpleBookCtrl",rb_cWXBookCtrlBase);
+	rb_define_alloc_func(rb_cWXSimplebook,_alloc);
+
+	rb_define_method(rb_cWXSimplebook,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	registerInfo<wxSimplebook>(rb_cWXSimplebook);
+
+	//registerEventType<wxBookCtrlEvent>("notebook_page_changed",wxEVT_NOTEBOOK_PAGE_CHANGED);
+	//registerEventType<wxBookCtrlEvent>("notebook_page_changing",wxEVT_NOTEBOOK_PAGE_CHANGING);
+#endif
+
+}
+
+
+
+
+

data/ext/wxSimpleBook.hpp

@@ -0,0 +1,21 @@
+/*
+ * wxSimplebook.hpp
+ *
+ *  Created on: 30.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXSIMPLEBOOK_HPP_
+#define WXSIMPLEBOOK_HPP_
+
+#include "wxEvtHandler.hpp"
+
+extern VALUE rb_cWXSimplebook;
+
+void Init_WXSimpleBookCtrl(VALUE rb_mWX);
+
+#if wxUSE_BOOKCTRL
+#include <wx/simplebook.h>
+#endif
+
+#endif /* WXSIMPLEBOOK_HPP_ */

data/ext/wxSingleChoiceDialog.cpp

@@ -0,0 +1,147 @@
+/*
+ * wxSingleChoiceDialog.cpp
+ *
+ *  Created on: 08.12.2013
+ *      Author: hanmac
+ */
+
+
+#include "wxAnyChoiceDialog.hpp"
+#include "wxSingleChoiceDialog.hpp"
+
+#include "wxApp.hpp"
+
+VALUE rb_cWXSingleChoiceDialog;
+
+#if wxUSE_CHOICEDLG
+#define _self unwrap<wxSingleChoiceDialog*>(self)
+
+namespace RubyWX {
+namespace SingleChoiceDialog {
+
+APP_PROTECT(wxSingleChoiceDialog)
+
+macro_attr(Selection,int)
+
+singlereturn(GetStringSelection)
+
+/*
+ * call-seq:
+ *   SingleChoiceDialog.new(parent, name, [options])
+ *   SingleChoiceDialog.new(parent, [options])
+ *
+ * creates a new SingleChoiceDialog 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:
+ *   * choices [string]
+ *   * selection Integer
+ *   * message String
+ *
+*/
+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(hash,rb_cString)){
+		int style(wxCHOICEDLG_STYLE);
+		int selection(-1);
+		wxArrayString choices;
+
+		wxString message(wxEmptyString);
+		wxString caption(wxEmptyString);
+
+		if(rb_obj_is_kind_of(hash,rb_cHash)){
+			set_hash_option(hash,"style",style);
+			set_hash_option(hash,"choices",choices);
+			set_hash_option(hash,"selection",selection);
+			set_hash_option(hash,"message",message);
+			set_hash_option(hash,"caption",caption);
+		}
+
+		_self->Create(unwrap<wxWindow*>(parent),message,caption,choices,(void **)NULL,style);
+		
+		if(check_index(selection,choices.GetCount()))
+			_self->SetSelection(selection);
+	}
+	rb_call_super(argc,argv);
+	return self;
+
+}
+
+
+VALUE _GetSingleChoice(int argc,VALUE *argv,VALUE self)
+{
+	VALUE message,caption,choices,hash;
+	rb_scan_args(argc, argv, "30:",&message,&caption,&choices,&hash);
+
+	app_protected();
+
+	wxWindow *parent = NULL;
+
+	int x(wxDefaultCoord);
+	int y(wxDefaultCoord);
+	bool centre(true);
+	int width(wxCHOICE_WIDTH);
+	int height(wxCHOICE_HEIGHT);
+
+	int selection(-1);
+
+	wxArrayString cchoices = unwrap<wxArrayString>(choices);
+
+	if(rb_obj_is_kind_of(hash,rb_cHash))
+	{
+
+		set_hash_option(hash,"parent",parent);
+		set_hash_option(hash,"x",x);
+		set_hash_option(hash,"y",y);
+
+		set_hash_option(hash,"center",centre);
+
+		set_hash_option(hash,"width",width);
+		set_hash_option(hash,"height",height);
+
+		if(set_hash_option(hash,"selection",selection))
+			if(!check_index(selection,cchoices.GetCount()))
+				return Qnil;
+	}
+
+	return wrap(wxGetSingleChoice(
+			unwrap<wxString>(message), unwrap<wxString>(caption),
+			cchoices,
+			parent, x, y, centre, width, height, selection
+	));
+}
+
+}
+}
+#endif
+DLL_LOCAL void Init_WXSingleChoiceDialog(VALUE rb_mWX)
+{
+#if 0
+	rb_cWXAnyChoiceDialog = rb_define_class_under(rb_mWX,"AnyChoiceDialog",rb_cWXDialog);
+
+	rb_define_attr(rb_cWXSingleChoiceDialog,"selection",1,1);
+#endif
+
+#if wxUSE_CHOICEDLG
+	using namespace RubyWX::SingleChoiceDialog;
+	rb_cWXSingleChoiceDialog = rb_define_class_under(rb_mWX,"SingleChoiceDialog",rb_cWXAnyChoiceDialog);
+	rb_define_alloc_func(rb_cWXSingleChoiceDialog,_alloc);
+
+	rb_define_method(rb_cWXSingleChoiceDialog,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_attr_method(rb_cWXSingleChoiceDialog,"selection",_getSelection,_setSelection);
+
+	rb_define_method(rb_cWXSingleChoiceDialog,"string_selection",RUBY_METHOD_FUNC(_GetStringSelection),0);
+
+	rb_define_module_function(rb_mWX,"single_choice",RUBY_METHOD_FUNC(_GetSingleChoice),-1);
+
+	registerInfo<wxSingleChoiceDialog>(rb_cWXSingleChoiceDialog);
+#endif
+}
+
+
+

data/ext/wxSingleChoiceDialog.hpp

@@ -0,0 +1,19 @@
+/*
+ * wxAnyChoiceDialog.hpp
+ *
+ *  Created on: 08.12.2013
+ *      Author: hanmac
+ */
+
+#ifndef WXSINGLECHOICEDIALOG_HPP_
+#define WXSINGLECHOICEDIALOG_HPP_
+
+#include "wxDialog.hpp"
+
+extern VALUE rb_cWXSingleChoiceDialog;
+
+void Init_WXSingleChoiceDialog(VALUE rb_mWX);
+#if wxUSE_CHOICEDLG
+#include <wx/choicdlg.h>
+#endif
+#endif /* WXSINGLECHOICEDIALOG_HPP_ */

data/ext/wxSize.cpp

@@ -0,0 +1,206 @@
+/*
+ * wxSize.cpp
+ *
+ *  Created on: 04.02.2012
+ *      Author: hanmac
+ */
+
+#include "wxSize.hpp"
+#include "wxRect.hpp"
+
+VALUE rb_cWXSize;
+
+#define _self unwrap<wxSize*>(self)
+
+ID rwxID_width,rwxID_height;
+
+template <>
+VALUE wrap< wxSize >(wxSize *size )
+{
+	return wrapTypedPtr(size, rb_cWXSize);
+}
+
+template <>
+bool is_wrapable< wxSize >(const VALUE &vsize)
+{
+	if (rb_obj_is_kind_of(vsize, rb_cWXSize)){
+		return true;
+	}else if(rb_respond_to(vsize,rwxID_width) &&
+		rb_respond_to(vsize,rwxID_height)){
+		return true;
+	}else
+		return false;
+}
+
+template <>
+wxSize unwrap< wxSize >(const VALUE &vsize)
+{
+	if(rb_obj_is_kind_of(vsize, rb_cArray)){
+			wxSize size;
+			size.SetWidth(NUM2INT(RARRAY_AREF(vsize,0)));
+			size.SetHeight(NUM2INT(RARRAY_AREF(vsize,1)));
+			return size;
+	}else if(rb_obj_is_kind_of(vsize, rb_cWXRect)){
+		return unwrapTypedPtr<wxRect>(vsize, rb_cWXRect)->GetSize();
+	}else if(!rb_obj_is_kind_of(vsize, rb_cWXSize) &&
+		rb_respond_to(vsize,rwxID_width) &&
+		rb_respond_to(vsize,rwxID_height)){
+		wxSize size;
+		size.SetWidth(NUM2INT(rb_funcall(vsize,rwxID_width,0)));
+		size.SetHeight(NUM2INT(rb_funcall(vsize,rwxID_height,0)));
+		return size;
+	}else{
+		return *unwrap<wxSize*>(vsize);
+	}
+}
+
+bool check_negative_size(VALUE val, wxSize &size)
+{
+	size = unwrap<wxSize>(val);
+	if(size.GetHeight() <= 0 && size.GetWidth() <= 0)
+	{
+		rb_raise(rb_eArgError,"%"PRIsVALUE" does have invalid size.", rb_inspect(val));
+		return false;
+	}
+	return true;
+}
+
+bool check_negative_size(const int &width, const int &height)
+{
+
+	if(height <= 0 && width <= 0)
+	{
+		rb_raise(rb_eArgError,
+			"%s(%d, %d) does have invalid size.",
+			rb_class2name(rb_cWXSize),
+			width, height
+		);
+		return false;
+	}
+	return true;
+}
+
+bool check_negative_size(const wxSize &size)
+{
+	return check_negative_size(size.GetWidth(), size.GetHeight());
+}
+
+namespace RubyWX {
+namespace Size {
+
+macro_attr(Width,int)
+macro_attr(Height,int)
+
+DLL_LOCAL VALUE _alloc(VALUE self)
+{
+	return wrap(new wxSize());
+}
+
+DLL_LOCAL VALUE _initialize(VALUE self,VALUE width,VALUE height)
+{
+	_setWidth(self,width);
+	_setHeight(self,height);
+	return self;
+}
+
+/*
+*/
+DLL_LOCAL VALUE _initialize_copy(VALUE self, VALUE other)
+{
+	VALUE result = rb_call_super(1,&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)",
+		rb_obj_classname( self ),
+		NUM2INT(_getWidth(self)),
+		NUM2INT(_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[2];
+    ptr[0] = _getWidth(self);
+    ptr[1] = _getHeight(self);
+    return rb_ary_new4(2, 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)
+{
+    _setWidth(self, RARRAY_AREF(data,0));
+    _setHeight(self, RARRAY_AREF(data,1));
+    return Qnil;
+}
+
+}
+}
+
+
+/*
+ * Document-class: WX::Size
+ *
+ * This class represents an Size.
+*/
+
+/* Document-attr: width
+ * returns the width value of Size. */
+/* Document-attr: height
+ * returns the height value of Size. */
+
+
+DLL_LOCAL void Init_WXSize(VALUE rb_mWX)
+{
+
+#if 0
+	rb_define_attr(rb_cWXSize,"width",1,1);
+	rb_define_attr(rb_cWXSize,"height",1,1);
+#endif
+
+	using namespace RubyWX::Size;
+	rb_cWXSize = rb_define_class_under(rb_mWX,"Size",rb_cObject);
+
+	rb_define_alloc_func(rb_cWXSize,_alloc);
+	rb_define_method(rb_cWXSize,"initialize",RUBY_METHOD_FUNC(_initialize),2);
+	rb_define_private_method(rb_cWXSize,"initialize_copy",RUBY_METHOD_FUNC(_initialize_copy),1);
+
+	rb_define_attr_method(rb_cWXSize,"width",_getWidth,_setWidth);
+	rb_define_attr_method(rb_cWXSize,"height",_getHeight,_setHeight);
+
+	rb_define_method(rb_cWXSize,"inspect",RUBY_METHOD_FUNC(_inspect),0);
+
+	rb_define_method(rb_cWXSize,"marshal_dump",RUBY_METHOD_FUNC(_marshal_dump),0);
+	rb_define_method(rb_cWXSize,"marshal_load",RUBY_METHOD_FUNC(_marshal_load),1);
+
+	registerType<wxSize>(rb_cWXSize, true);
+
+	rwxID_width = rb_intern("width");
+	rwxID_height = rb_intern("height");
+}