rwx 0.0.1.dev

data/ext/wxPreferences.cpp

@@ -0,0 +1,149 @@
+/*
+ * wxPreferences.cpp
+ *
+ *  Created on: 25.05.2013
+ *      Author: hanmac
+ */
+
+#include "main.hpp"
+
+#include "wxApp.hpp"
+
+VALUE rb_cWXPreferences;
+
+#ifdef HAVE_WX_PREFERENCES_H
+
+#include <wx/preferences.h>
+
+template <>
+VALUE wrap< wxPreferencesEditor >(wxPreferencesEditor *point )
+{
+	return wrapTypedPtr(point, rb_cWXPreferences);
+}
+
+#define _self unwrap<wxPreferencesEditor*>(self)
+
+class RubyPreferencesPageInterface
+{
+public:
+	RubyPreferencesPageInterface(VALUE block,VALUE klass) :
+		mblock(block),mklass(klass) {}
+
+	virtual ~RubyPreferencesPageInterface() {}
+
+	virtual wxWindow *CreateWindow(wxWindow *parent)
+	{
+		//VALUE argv[] = {wrap(parent)};
+		//VALUE result = rb_class_new_instance(1,argv,mklass);
+
+		VALUE result = rb_funcall(mklass,rb_intern("new"),1,wrap(parent));
+
+		if(!NIL_P(mblock))
+			rb_funcall(mblock,rb_intern("call"),1,result);
+
+		return unwrap<wxWindow*>(result);
+	}
+
+private:
+	VALUE mblock;
+	VALUE mklass;
+};
+
+class RubyPreferencesPage : public RubyPreferencesPageInterface,public wxPreferencesPage
+{
+public:
+	RubyPreferencesPage(VALUE block,VALUE klass,const wxString &title) :
+		RubyPreferencesPageInterface(block,klass),wxPreferencesPage(),mtitle(title) {}
+
+	//using RubyPreferencesPageInterface::CreateWindow;
+	wxWindow *CreateWindow(wxWindow *parent)
+	{
+		return RubyPreferencesPageInterface::CreateWindow(parent);
+	}
+
+	wxString GetName() const {return mtitle;}
+private:
+	wxString mtitle;
+};
+
+
+class RubyStockPreferencesPage : public RubyPreferencesPageInterface, public wxStockPreferencesPage
+{
+public:
+	RubyStockPreferencesPage(VALUE block,VALUE klass,wxStockPreferencesPage::Kind kind) :
+		RubyPreferencesPageInterface(block,klass), wxStockPreferencesPage(kind) {}
+
+	//using RubyPreferencesPageInterface::CreateWindow;
+	wxWindow *CreateWindow(wxWindow *parent)
+	{
+		return RubyPreferencesPageInterface::CreateWindow(parent);
+	}
+};
+
+namespace RubyWX {
+namespace Preferences {
+
+DLL_LOCAL VALUE _add_page(int argc,VALUE *argv,VALUE self)
+{
+	VALUE kind, klass,block;
+	rb_scan_args(argc, argv, "20&",&kind,&klass,&block);
+	wxPreferencesPage *page = NULL;
+	//VALUE block = rb_block_proc();
+	if(SYMBOL_P(kind))
+	{
+		wxStockPreferencesPage::Kind wxkind = wxStockPreferencesPage::Kind_General;
+		if(SYM2ID(kind) == rb_intern("general"))
+			wxkind = wxStockPreferencesPage::Kind_General;
+		if(SYM2ID(kind) == rb_intern("advanced"))
+			wxkind = wxStockPreferencesPage::Kind_Advanced;
+		page = new RubyStockPreferencesPage(block,klass,wxkind);
+	}else
+	{
+		page = new RubyPreferencesPage(block,klass,unwrap<wxString>(kind));
+	}
+
+	_self->AddPage(page);
+	return self;
+}
+
+DLL_LOCAL VALUE _preferences(int argc,VALUE *argv,VALUE self)
+{
+	VALUE window, title;
+	rb_scan_args(argc, argv, "11",&window,&title);
+
+	app_protected();
+
+	wxPreferencesEditor *pref = new wxPreferencesEditor(unwrap<wxString>(title));
+
+	if(rb_block_given_p())
+	{
+		rb_funcall(rb_block_proc(),rb_intern("call"),1,wrap(pref));
+		//rb_yield(wrap(pref));
+		pref->Show(unwrap<wxWindow*>(window));
+	}
+
+	return self;
+}
+
+}
+
+}
+
+#endif
+
+DLL_LOCAL void Init_WXPreferences(VALUE rb_mWX)
+{
+#ifdef HAVE_WX_PREFERENCES_H
+	using namespace RubyWX::Preferences;
+	rb_cWXPreferences = rb_define_class_under(rb_mWX,"Preferences",rb_cObject);
+
+	rb_undef_alloc_func(rb_cWXPreferences);
+
+	rb_define_method(rb_cWXPreferences,"add_page",RUBY_METHOD_FUNC(_add_page),-1);
+
+	rb_define_module_function(rb_mWX,"preferences",RUBY_METHOD_FUNC(_preferences),-1);
+	registerType<wxPreferencesEditor>(rb_cWXPreferences);
+#endif
+
+}
+

data/ext/wxPreferences.hpp

@@ -0,0 +1,18 @@
+/*
+ * wxPreferences.hpp
+ *
+ *  Created on: 26.05.2013
+ *      Author: hanmac
+ */
+
+#ifndef WXPREFERENCES_HPP_
+#define WXPREFERENCES_HPP_
+
+#include "main.hpp"
+
+extern VALUE rb_cWXPreferences;
+
+DLL_LOCAL void Init_WXPreferences(VALUE rb_mWX);
+
+
+#endif /* WXPREFERENCES_HPP_ */

data/ext/wxProgressDialog.cpp

@@ -0,0 +1,171 @@
+/*
+ * wxProgressDialog.cpp
+ *
+ *  Created on: 11.03.2012
+ *      Author: hanmac
+ */
+
+#include "wxProgressDialog.hpp"
+
+VALUE rb_cWXProgressDialog;
+#if wxUSE_PROGRESSDLG
+
+#ifdef HAVE_WXPROGRESSDIALOG
+#define _self unwrap<wxProgressDialog*>(self)
+#else
+#define _self unwrap<wxGenericProgressDialog*>(self)
+#endif
+
+
+namespace RubyWX {
+namespace ProgressDialog {
+
+macro_attr(Range,int)
+
+singlereturn(GetValue)
+singlereturn(GetMessage)
+
+#ifdef HAVE_WXPROGRESSDIALOG
+APP_PROTECT(wxProgressDialog)
+#else
+APP_PROTECT(wxGenericProgressDialog)
+#endif
+
+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))
+	{
+		wxString title(wxEmptyString);
+		wxString message(wxEmptyString);
+		int max(100);
+		int style(wxPD_APP_MODAL | wxPD_AUTO_HIDE);
+
+		if(rb_obj_is_kind_of(hash,rb_cHash))
+		{
+			set_hash_option(hash,"title",title);
+			set_hash_option(hash,"message",message);
+
+			set_hash_option(hash,"max",max);
+
+			set_hash_option(hash,"style",style);
+
+			TopLevel::set_style_flags(hash,style);
+
+			set_hash_flag_option(hash,"can_abort",wxPD_CAN_ABORT,style);
+			set_hash_flag_option(hash,"app_modal",wxPD_APP_MODAL,style);
+			set_hash_flag_option(hash,"auto_hide",wxPD_AUTO_HIDE,style);
+			set_hash_flag_option(hash,"smooth",wxPD_SMOOTH,style);
+			set_hash_flag_option(hash,"can_skip",wxPD_CAN_SKIP,style);
+			set_hash_flag_option(hash,"elapsed_time",wxPD_ELAPSED_TIME,style);
+			set_hash_flag_option(hash,"estimated_time",wxPD_ESTIMATED_TIME,style);
+			set_hash_flag_option(hash,"remaining_time",wxPD_REMAINING_TIME,style);
+
+		}
+		_self->Create(title,message,max,unwrap<wxWindow*>(parent),style);
+
+	}
+	rb_call_super(argc,argv);
+
+	return self;
+}
+
+DLL_LOCAL VALUE _update(int argc,VALUE *argv,VALUE self)
+{
+	VALUE val,message;
+	rb_scan_args(argc, argv, "11",&val,&message);
+
+	int value = NUM2INT(val);
+
+	if(check_index(value,_self->GetRange()))
+		return wrap(_self->Update(value,unwrap<wxString>(message)));
+	return Qnil;
+}
+
+DLL_LOCAL VALUE _pulse(int argc,VALUE *argv,VALUE self)
+{
+	VALUE message;
+	rb_scan_args(argc, argv, "01",&message);
+
+	return wrap(_self->Pulse(unwrap<wxString>(message)));
+}
+
+
+}
+}
+#endif
+
+
+/* Document-const: APP_MODAL
+ *   Make the progress dialog modal.
+ *   If this flag is not given, it is only "locally" modal
+ *   - that is the input to the parent window is disabled,
+ *   but not to the other ones.
+ */
+/* Document-const: CAN_ABORT
+ *   This flag tells the dialog that it should have a "Cancel" button which the user may press.
+ *   If this happens, the next call to update() will return false
+ */
+/* Document-const: CAN_SKIP
+ *   This flag tells the dialog that it should have a "Skip" button which the user may press.
+ *   If this happens, the next call to Update() will return true in its skip parameter.
+ */
+/* Document-const: AUTO_HIDE
+ *   Causes the progress dialog to disappear from screen as soon as the maximum value of the progress meter has been reached.
+ *   If this style is not present, the dialog will become a modal dialog (see WX::Dialog#show_modal) once the maximum value has been reached and wait for the user to dismiss it.
+ */
+/* Document-const: SMOOTH
+ *   Causes smooth progress of the gauge control (uses a WX::Gauge with the WX::Gauge::SMOOTH style).
+ */
+/* Document-const: ELAPSED_TIME
+ *   The text will not be user-editable.
+ */
+/* Document-const: ESTIMATED_TIME
+ *   The text will not be user-editable.
+ */
+/* Document-const: REMAINING_TIME
+ *   The text will not be user-editable.
+ */
+
+
+DLL_LOCAL void Init_WXProgressDialog(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);
+
+#endif
+
+#if wxUSE_PROGRESSDLG
+	using namespace RubyWX::ProgressDialog;
+	rb_cWXProgressDialog = rb_define_class_under(rb_mWX,"ProgressDialog",rb_cWXDialog);
+	rb_define_alloc_func(rb_cWXProgressDialog,_alloc);
+	rb_define_method(rb_cWXProgressDialog,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_method(rb_cWXProgressDialog,"update",RUBY_METHOD_FUNC(_update),-1);
+	rb_define_method(rb_cWXProgressDialog,"pulse",RUBY_METHOD_FUNC(_pulse),-1);
+
+
+	rb_define_const(rb_cWXProgressDialog,"CAN_ABORT",INT2NUM(wxPD_CAN_ABORT));
+	rb_define_const(rb_cWXProgressDialog,"APP_MODAL",INT2NUM(wxPD_APP_MODAL));
+	rb_define_const(rb_cWXProgressDialog,"AUTO_HIDE",INT2NUM(wxPD_AUTO_HIDE));
+	rb_define_const(rb_cWXProgressDialog,"ELAPSED_TIME",INT2NUM(wxPD_ELAPSED_TIME));
+	rb_define_const(rb_cWXProgressDialog,"ESTIMATED_TIME",INT2NUM(wxPD_ESTIMATED_TIME));
+	rb_define_const(rb_cWXProgressDialog,"SMOOTH",INT2NUM(wxPD_SMOOTH));
+	rb_define_const(rb_cWXProgressDialog,"REMAINING_TIME",INT2NUM(wxPD_REMAINING_TIME));
+	rb_define_const(rb_cWXProgressDialog,"CAN_SKIP",INT2NUM(wxPD_CAN_SKIP));
+
+#ifdef HAVE_WXPROGRESSDIALOG
+	registerInfo<wxProgressDialog>(rb_cWXProgressDialog);
+#else
+	registerInfo<wxGenericProgressDialog>(rb_cWXProgressDialog);
+	registerInfo<wxProgressDialog>(rb_cWXProgressDialog);
+#endif
+
+
+#endif
+}

data/ext/wxProgressDialog.hpp

@@ -0,0 +1,20 @@
+/*
+ * wxProgressDialog.hpp
+ *
+ *  Created on: 11.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXPROGRESSDIALOG_HPP_
+#define WXPROGRESSDIALOG_HPP_
+
+#include "wxDialog.hpp"
+
+extern VALUE rb_cWXProgressDialog;
+
+DLL_LOCAL void Init_WXProgressDialog(VALUE rb_mWX);
+#if wxUSE_PROGRESSDLG
+#include <wx/progdlg.h>
+#endif
+
+#endif /* WXPROGRESSDIALOG_HPP_ */

data/ext/wxProperty.cpp

@@ -0,0 +1,723 @@
+/*
+ * wxProperty.cpp
+ *
+ *  Created on: 08.05.2012
+ *      Author: hanmac
+ */
+
+#include "wxProperty.hpp"
+#include "wxPropertyGrid.hpp"
+#include "wxVariant.hpp"
+#include "wxBitmap.hpp"
+#include "wxColor.hpp"
+#include "wxFont.hpp"
+#include "wxApp.hpp"
+
+VALUE rb_cWXProperty;
+#if wxUSE_PROPGRID
+
+#include <wx/propgrid/props.h>
+#include <wx/propgrid/advprops.h>
+
+template<typename T>
+DLL_LOCAL void registerProperty(VALUE mod,const char* name,const char* parent = NULL)
+{
+	VALUE pc = rb_cWXProperty;
+	
+	if(parent)
+		pc = rb_const_get(mod,rb_intern(parent));
+	
+	VALUE klass = rb_define_class_under(mod,name,pc);
+	registerInfo<T>(klass);
+}
+
+
+#define _self unwrap<wxPGProperty*>(self)
+
+namespace RubyWX {
+namespace Property {
+
+//APP_PROTECT(wxPGProperty)
+
+DLL_LOCAL VALUE _alloc(VALUE self)
+{
+	app_protected();
+
+	for(VALUE klass = self; klass != rb_cWXProperty; klass = rb_class_get_superclass(klass))
+	{
+		for(infoholdertype::const_iterator it = infoklassholder.begin(); it != infoklassholder.end();++it) {
+			if(it->second == klass) {
+				return wrapTypedPtr(it->first->CreateObject(),self);
+			}
+		}
+	}
+
+	return wrapTypedPtr(new wxPGProperty,self);
+}
+
+macro_attr(Name,wxString)
+macro_attr(Label,wxString)
+macro_attr(HelpString,wxString)
+
+singlereturn(GetBaseName)
+singlereturn(GetMainParent)
+singlereturn(GetParent)
+
+singlereturn(GetDepth)
+
+singlereturn(GetGrid)
+
+singlereturn(IsVisible)
+singlereturn(IsRoot)
+singlereturn(IsCategory)
+
+singlereturn(HasVisibleChildren)
+
+singlereturn(GetValue)
+singlereturn(GetDefaultValue)
+singlereturn(GetValueImage)
+
+singlereturn(GetValueType)
+
+singlefunc(DeleteChildren)
+
+macro_attr_selection(ChoiceSelection,GetChoices().GetCount)
+
+macro_attr_bool(Expanded)
+macro_attr_bool2(Enabled,Enable)
+
+DLL_LOCAL VALUE _setValue(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+	_self->SetValue(unwrapVariant(val,_self->GetValueType()));
+	return val;
+}
+
+DLL_LOCAL VALUE _setDefaultValue(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+	wxVariant var = unwrapVariant(val,_self->GetValueType());
+	_self->SetDefaultValue(var);
+	return val;
+}
+
+DLL_LOCAL VALUE _setValueImage(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+
+	if(_self->GetGrid())
+		_self->SetValueImage(unwrap<wxBitmap&>(val));
+
+	return val;
+}
+
+
+DLL_LOCAL VALUE _getAttribute(VALUE self,VALUE name)
+{
+	return wrap(_self->GetAttribute(unwrap<wxString>(name)));
+}
+
+DLL_LOCAL VALUE _setAttribute(VALUE self,VALUE name,VALUE val)
+{
+	rb_check_frozen(self);
+	_self->SetAttribute(unwrap<wxString>(name),unwrapVariant(val,_self->GetAttribute(unwrap<wxString>(name)).GetType()));
+	return val;
+}
+
+DLL_LOCAL VALUE _getClass(VALUE self)
+{
+	return wrap(wxString(_self->GetClassInfo()->GetClassName()));
+}
+
+
+DLL_LOCAL VALUE _setVisible(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+	_self->Hide(!RTEST(val));
+	return val;
+}
+
+/*
+ * call-seq:
+ *   show([recurse]) -> self
+ *
+ * makes this property visible, children too if recurse is set.
+ * ===Arguments
+ * * recurse true/false
+ * ===Return value
+ * self
+ *
+*/
+DLL_LOCAL VALUE _show(int argc,VALUE *argv,VALUE self)
+{
+	rb_check_frozen(self);
+
+	VALUE recurse;
+
+	rb_scan_args(argc, argv, "01",&recurse);
+
+	bool rec = NIL_P(recurse) || RTEST(recurse);
+	_self->Hide(false, rec ? wxPG_RECURSE : wxPG_DONT_RECURSE );
+	return self;
+}
+
+
+/*
+ * call-seq:
+ *   hide([recurse]) -> self
+ *
+ * hides this property, children too if recurse is set.
+ * ===Arguments
+ * * recurse true/false
+ * ===Return value
+ * self
+ *
+*/
+DLL_LOCAL VALUE _hide(int argc,VALUE *argv,VALUE self)
+{
+	rb_check_frozen(self);
+
+	VALUE recurse;
+
+	rb_scan_args(argc, argv, "01",&recurse);
+
+	bool rec = NIL_P(recurse) || RTEST(recurse);
+	_self->Hide(true, rec ? wxPG_RECURSE : wxPG_DONT_RECURSE );
+	return self;
+}
+
+
+
+DLL_LOCAL VALUE _each_child_size(VALUE self)
+{
+	return UINT2NUM(_self->GetChildCount());
+}
+
+
+
+/*
+ * call-seq:
+ *   each_child -> Enumerator
+ *   each_child { |child| } -> self
+ *
+ * iterates the children in this property.
+ * ===Return value
+ * self
+ *
+*/
+DLL_LOCAL VALUE _each_child(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self,0,NULL,RUBY_METHOD_FUNC(_each_child_size));
+	std::size_t count = _self->GetChildCount();
+	for(std::size_t i = 0; i < count; ++i)
+		rb_yield(wrap(_self->Item(i)));
+	return self;
+}
+
+DLL_LOCAL VALUE _each_choice_count(VALUE self)
+{
+	const wxPGChoices& choices = _self->GetChoices();
+	if(!choices.IsOk())
+		return INT2FIX(0);
+
+	return wrap(choices.GetCount());
+}
+
+
+
+/*
+ * call-seq:
+ *   each_choice -> Enumerator
+ *   each_choice { |child| } -> self
+ *
+ * iterates the choices in this property.
+ * ===Return value
+ * self
+ *
+*/
+DLL_LOCAL VALUE _each_choice(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self,0,NULL,RUBY_METHOD_FUNC(_each_choice_count));
+	wxPGChoices& choices = const_cast<wxPGChoices&>(_self->GetChoices());
+
+	if(!choices.IsOk())
+		return self;
+
+	std::size_t count = choices.GetCount();
+	for(std::size_t i = 0; i < count; ++i)
+	{
+		rb_yield(wrap(&dynamic_cast<wxPGCell&>(choices[i])));
+	}
+
+
+	return self;
+}
+
+
+VALUE _set_choice(wxPGProperty* self,int idx,VALUE hash)
+{
+	wxPGChoices& choices = const_cast<wxPGChoices&>(self->GetChoices());
+
+	if(!choices.IsOk())
+		return Qnil;
+
+	wxPGChoiceEntry& item = choices[idx];
+
+	if(rb_obj_is_kind_of(hash,rb_cHash))
+	{
+		wxBitmap bitmap;
+		wxColour fg,bg;
+		wxFont font(wxNullFont);
+
+		if(set_hash_option(hash,"bitmap",bitmap))
+			item.SetBitmap(bitmap);
+
+		if(set_hash_option(hash,"bg_col",bg))
+			item.SetBgCol(bg);
+		if(set_hash_option(hash,"fg_col",fg))
+			item.SetFgCol(fg);
+		if(set_hash_option(hash,"font",font))
+			item.SetFont(font);
+	}
+	return wrap(&dynamic_cast<wxPGCell&>(item));
+}
+
+
+/*
+ * call-seq:
+ *   add_choice(label,[value],**options) -> WX::PropertyCell
+ *
+ * adds a new choice into this property
+ * ===Arguments
+ * * label String
+ * * value Integer/nil
+ * * options:
+ *   * bitmap WX::Bitmap
+ *   * bg_col WX::Color
+ *   * fg_col WX::Color
+ *   * font WX::Font
+ * ===Return value
+ * WX::PropertyCell
+ *
+*/
+DLL_LOCAL VALUE _add_choice(int argc,VALUE *argv,VALUE self)
+{
+	VALUE label,value,hash;
+
+	rb_scan_args(argc, argv, "11:",&label,&value,&hash);
+
+	int cvalue = wxPG_INVALID_VALUE;
+
+	if(!NIL_P(value))
+		cvalue = NUM2INT(value);
+
+	return _set_choice(_self,_self->AddChoice(unwrap<wxString>(label),cvalue),hash);
+
+}
+
+/*
+ * call-seq:
+ *   prepend_choice(pos,label,[value],**options) -> WX::PropertyCell
+ *
+ * prepends a new choice into this property
+ * ===Arguments
+ * * pos position of the new choice. Integer
+ * * label String
+ * * value Integer/nil
+ * * options:
+ *   * bitmap WX::Bitmap
+ *   * bg_col WX::Color
+ *   * fg_col WX::Color
+ *   * font WX::Font
+ * ===Return value
+ * WX::PropertyCell
+ * === Exceptions
+ * [IndexError]
+ * * pos is greater than the count of choices
+ *
+*/
+DLL_LOCAL VALUE _insert_choice(int argc,VALUE *argv,VALUE self)
+{
+	VALUE label,idx,value,hash;
+
+	rb_scan_args(argc, argv, "21:",&idx,&label,&value,&hash);
+
+	int cvalue = wxPG_INVALID_VALUE;
+
+	int cidx = NUM2INT(idx);
+
+	std::size_t size = 0;
+
+	const wxPGChoices& choices = _self->GetChoices();
+	if(choices.IsOk())
+		size = choices.GetCount();
+
+	if(!NIL_P(value))
+		cvalue = NUM2INT(value);
+
+	if(check_index(cidx,size+1))
+		return _set_choice(_self,_self->InsertChoice(unwrap<wxString>(label),cidx,cvalue),hash);
+	return Qnil;
+}
+
+
+/*
+ * call-seq:
+ *   prepend_choice(label,[value],**options) -> WX::PropertyCell
+ *
+ * prepends a new choice into this property
+ * ===Arguments
+ * * label String
+ * * value Integer/nil
+ * * options:
+ *   * bitmap WX::Bitmap
+ *   * bg_col WX::Color
+ *   * fg_col WX::Color
+ *   * font WX::Font
+ * ===Return value
+ * WX::PropertyCell
+ *
+*/
+DLL_LOCAL VALUE _prepend_choice(int argc,VALUE *argv,VALUE self)
+{
+	VALUE label,value,hash;
+
+	rb_scan_args(argc, argv, "11:",&label,&value,&hash);
+
+	int cvalue = wxPG_INVALID_VALUE;
+
+	if(!NIL_P(value))
+		cvalue = NUM2INT(value);
+
+	return _set_choice(_self,_self->InsertChoice(unwrap<wxString>(label),0,cvalue),hash);
+
+}
+
+
+/*
+ * call-seq:
+ *   delete_choice(pos) -> self
+ *
+ * delete the choice at the given position.
+ * ===Arguments
+ * * pos position of the deleting choice. Integer
+ * ===Return value
+ * self
+ * === Exceptions
+ * [IndexError]
+ * * pos is greater than the count of choices
+ *
+*/
+DLL_LOCAL VALUE _delete_choice(VALUE self,VALUE idx)
+{
+
+	int cidx = NUM2INT(idx);
+
+	std::size_t size = 0;
+
+	const wxPGChoices& choices = _self->GetChoices();
+	if(choices.IsOk())
+		size = choices.GetCount();
+
+	if(check_index(cidx,size))
+		_self->DeleteChoice(cidx);
+
+	return self;
+}
+
+
+/*
+ * call-seq:
+ *   add_child(property) -> WX::Property
+ *   add_child(property) { |property| } -> WX::Property
+ *
+ * adds a new Property as child into this one
+ * ===Arguments
+ * * property WX::Property or class that inherits from WX::Property
+ * ===Return value
+ * WX::Property
+ *
+*/
+DLL_LOCAL VALUE _add_child(VALUE self,VALUE prop)
+{
+	return wrap(_self->AppendChild(unwrap<wxPGProperty*>(prop)));
+}
+
+
+/*
+ * call-seq:
+ *   add_private_child(property) -> self
+ *
+ * adds a new Property as private child into this one
+ * ===Arguments
+ * * property WX::Property or class that inherits from WX::Property
+ * ===Return value
+ * self
+ *
+*/
+DLL_LOCAL VALUE _add_private_child(VALUE self,VALUE prop)
+{
+	_self->AddPrivateChild(unwrap<wxPGProperty*>(prop));
+	return self;
+}
+
+
+/*
+ * call-seq:
+ *   insert_child(pos,property) -> WX::Property
+ *   insert_child(pos,property) { |property| } -> WX::Property
+ *
+ * adds a new Property as child into this one
+ * ===Arguments
+ * * pos position of the new child property. Integer
+ * * property WX::Property or class that inherits from WX::Property
+ * ===Return value
+ * WX::Property
+ * === Exceptions
+ * [IndexError]
+ * * pos is greater than the count of children
+ *
+*/
+DLL_LOCAL VALUE _insert_child(VALUE self,VALUE idx,VALUE prop)
+{
+	int cidx = NUM2INT(idx);
+
+	if(check_index(cidx,_self->GetChildCount()+1))
+		return wrap(_self->InsertChild(cidx,unwrap<wxPGProperty*>(prop)));
+
+	return Qnil;
+}
+
+
+/*
+ * call-seq:
+ *   prepend_child(property) -> WX::Property
+ *   prepend_child(property) { |property| } -> WX::Property
+ *
+ * prepends a new Property as child into this one
+ * ===Arguments
+ * * property WX::Property or class that inherits from WX::Property
+ * ===Return value
+ * WX::Property
+ *
+*/
+DLL_LOCAL VALUE _prepend_child(VALUE self,VALUE prop)
+{
+	return wrap(_self->InsertChild(0,unwrap<wxPGProperty*>(prop)));
+}
+
+
+
+
+DLL_LOCAL VALUE _each_attribute_size(VALUE self)
+{
+	return wrap(_self->GetAttributes().GetCount());
+}
+
+
+/*
+ * call-seq:
+ *   each_attribute -> Enumerator
+ *   each_attribute { |name, value| } -> self
+ *
+ * iterates the attributes in this property.
+ * ===Return value
+ * self
+ *
+*/
+DLL_LOCAL VALUE _each_attribute(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self,0,NULL,RUBY_METHOD_FUNC(_each_attribute_size));
+
+	const wxPGAttributeStorage& attrs = _self->GetAttributes();
+
+	wxPGAttributeStorage::const_iterator it = attrs.StartIteration();
+	wxVariant var;
+	while(attrs.GetNext(it,var))
+		rb_yield_values(2,wrap(var.GetName()),wrap(var));
+	return self;
+}
+
+
+VALUE find_prop_class(VALUE self,VALUE name)
+{
+	return wxClassInfo::FindClass(wxString("wx") + unwrap<wxString>(name)) ? Qtrue : Qfalse;
+}
+
+}
+}
+
+#endif
+
+/* Document-attr: label
+ * the label of the Property. String
+ */
+/* Document-attr: name
+ * the name of the Property. String
+ */
+/* Document-attr: help_string
+ * the help string of the Property. String
+ */
+/* Document-attr: value
+ * the value of the Property.
+ */
+/* Document-attr: default_value
+ * the default_value of the Property.
+ */
+/* Document-attr: value_image
+ * the image of the Property. WX::Bitmap
+ */
+
+/* Document-attr: visible
+ * the visible of the Property. bool
+ */
+
+/* Document-attr: expanded
+ * the expanded of the Property. bool
+ */
+
+/* Document-attr: enabled
+ * the enabled of the Property. bool
+ */
+
+/* Document-attr: choice_selection
+ * the index with choice of the Property is selected. Integer/nil
+ */
+
+
+/* Document-attr: parent
+ * the parent property of this one. WX::Property or nil
+ */
+/* Document-attr: main_parent
+ * highest level parent property of this one. WX::Property or nil
+ */
+/* Document-attr: base_name
+ * the base name of the Property. String
+ */
+
+/* Document-attr: depth
+ * the depth of this property inside a grid. Integer
+ */
+/* Document-attr: grid
+ * the property grid that has this property. WX::PropertyGrid or nil
+ */
+DLL_LOCAL void Init_WXProperty(VALUE rb_mWX)
+{
+#if 0
+
+	rb_define_attr(rb_cWXProperty,"name",1,1);
+	rb_define_attr(rb_cWXProperty,"label",1,1);
+	rb_define_attr(rb_cWXProperty,"help_string",1,1);
+
+	rb_define_attr(rb_cWXProperty,"value",1,1);
+	rb_define_attr(rb_cWXProperty,"default_value",1,1);
+	rb_define_attr(rb_cWXProperty,"value_image",1,1);
+
+	rb_define_attr(rb_cWXProperty,"visible",1,1);
+	rb_define_attr(rb_cWXProperty,"expanded",1,1);
+	rb_define_attr(rb_cWXProperty,"enabled",1,1);
+
+	rb_define_attr(rb_cWXProperty,"choice_selection",1,1);
+
+	rb_define_attr(rb_cWXProperty,"base_name",1,0);
+	rb_define_attr(rb_cWXProperty,"main_parent",1,0);
+	rb_define_attr(rb_cWXProperty,"parent",1,0);
+
+	rb_define_attr(rb_cWXProperty,"depth",1,0);
+	rb_define_attr(rb_cWXProperty,"grid",1,0);
+
+#endif
+
+#if wxUSE_PROPGRID
+	using namespace RubyWX::Property;
+	rb_cWXProperty = rb_define_class_under(rb_mWX,"Property",rb_cObject);
+	rb_define_alloc_func(rb_cWXProperty,_alloc);
+
+	//TODO check if its possible to add this methods
+	rb_undef_method(rb_cWXProperty,"initialize_copy");
+	rb_undef_method(rb_cWXProperty,"_load");
+	rb_undef_method(rb_cWXProperty,"_dump");
+
+	rb_define_method(rb_cWXProperty,"visible_children?",RUBY_METHOD_FUNC(_HasVisibleChildren),0);
+	rb_define_method(rb_cWXProperty,"root?",RUBY_METHOD_FUNC(_IsRoot),0);
+	rb_define_method(rb_cWXProperty,"category?",RUBY_METHOD_FUNC(_IsCategory),0);
+
+	rb_define_attr_method(rb_cWXProperty,"name",_getName,_setName);
+	rb_define_attr_method(rb_cWXProperty,"label",_getLabel,_setLabel);
+	rb_define_attr_method(rb_cWXProperty,"help_string",_getHelpString,_setHelpString);
+
+	rb_define_attr_method(rb_cWXProperty,"value",_GetValue,_setValue);
+	rb_define_attr_method(rb_cWXProperty,"default_value",_GetDefaultValue,_setDefaultValue);
+	rb_define_attr_method(rb_cWXProperty,"value_image",_GetValueImage,_setValueImage);
+
+	rb_define_attr_method(rb_cWXProperty,"visible",_IsVisible,_setVisible);
+	rb_define_attr_method(rb_cWXProperty,"expanded",_getExpanded,_setExpanded);
+	rb_define_attr_method(rb_cWXProperty,"enabled",_getEnabled,_setEnabled);
+
+	rb_define_attr_method(rb_cWXProperty,"choice_selection",_getChoiceSelection,_setChoiceSelection);
+
+	rb_define_attr_method(rb_cWXProperty,"base_name",_GetBaseName,0);
+	rb_define_attr_method(rb_cWXProperty,"main_parent",_GetMainParent,0);
+	rb_define_attr_method(rb_cWXProperty,"parent",_GetParent,0);
+
+	rb_define_attr_method(rb_cWXProperty,"depth",_GetDepth,0);
+	rb_define_attr_method(rb_cWXProperty,"grid",_GetGrid,0);
+
+	rb_define_method(rb_cWXProperty,"show",RUBY_METHOD_FUNC(_show),-1);
+	rb_define_method(rb_cWXProperty,"hide",RUBY_METHOD_FUNC(_hide),-1);
+
+	rb_define_method(rb_cWXProperty,"add_child",RUBY_METHOD_FUNC(_add_child),1);
+	rb_define_method(rb_cWXProperty,"add_private_child",RUBY_METHOD_FUNC(_add_private_child),1);
+	rb_define_method(rb_cWXProperty,"insert_child",RUBY_METHOD_FUNC(_insert_child),2);
+	rb_define_method(rb_cWXProperty,"prepend_child",RUBY_METHOD_FUNC(_prepend_child),1);
+
+	rb_define_method(rb_cWXProperty,"add_choice",RUBY_METHOD_FUNC(_add_choice),-1);
+	rb_define_method(rb_cWXProperty,"insert_choice",RUBY_METHOD_FUNC(_insert_choice),-1);
+	rb_define_method(rb_cWXProperty,"prepend_choice",RUBY_METHOD_FUNC(_prepend_choice),-1);
+
+	rb_define_method(rb_cWXProperty,"delete_children",RUBY_METHOD_FUNC(_DeleteChildren),0);
+	rb_define_method(rb_cWXProperty,"delete_choice",RUBY_METHOD_FUNC(_delete_choice),1);
+
+	rb_define_method(rb_cWXProperty,"each_child",RUBY_METHOD_FUNC(_each_child),0);
+	rb_define_method(rb_cWXProperty,"each_choice",RUBY_METHOD_FUNC(_each_choice),0);
+	rb_define_method(rb_cWXProperty,"each_attribute",RUBY_METHOD_FUNC(_each_attribute),0);
+
+	rb_define_method(rb_cWXProperty,"wxclass",RUBY_METHOD_FUNC(_getClass),0);
+	rb_define_method(rb_cWXProperty,"type",RUBY_METHOD_FUNC(_GetValueType),0);
+
+	rb_define_method(rb_cWXProperty,"[]",RUBY_METHOD_FUNC(_getAttribute),1);
+	rb_define_method(rb_cWXProperty,"[]=",RUBY_METHOD_FUNC(_setAttribute),2);
+
+	registerInfo<wxPGProperty>(rb_cWXProperty);
+	
+	rb_define_singleton_method(rb_cWXProperty,"find",RUBY_METHOD_FUNC(find_prop_class),1);
+	
+	registerProperty<wxIntProperty>(rb_mWX,"IntProperty");
+	registerProperty<wxPropertyCategory>(rb_mWX,"CategoryProperty");
+	registerProperty<wxBoolProperty>(rb_mWX,"BoolProperty");
+	registerProperty<wxFontProperty>(rb_mWX,"FontProperty");
+	registerProperty<wxFileProperty>(rb_mWX,"FileProperty");
+
+#if wxUSE_IMAGE
+	registerProperty<wxImageFileProperty>(rb_mWX,"ImageFileProperty","FileProperty");
+#endif
+
+#if wxUSE_DATETIME
+	registerProperty<wxDateProperty>(rb_mWX,"DateProperty");
+#endif
+
+	registerProperty<wxStringProperty>(rb_mWX,"StringProperty");
+	registerProperty<wxArrayStringProperty>(rb_mWX,"ArrayStringProperty");
+	
+	registerProperty<wxEnumProperty>(rb_mWX,"EnumProperty");
+	registerProperty<wxFlagsProperty>(rb_mWX,"FlagsProperty");
+	
+	registerProperty<wxSystemColourProperty>(rb_mWX,"SystemColorProperty","EnumProperty");
+	registerProperty<wxColourProperty>(rb_mWX,"ColorProperty","SystemColorProperty");
+	registerProperty<wxCursorProperty>(rb_mWX,"CursorProperty","EnumProperty");
+	
+#endif
+}
+
+
+