rwx 0.0.1.dev

data/ext/wxButton.hpp

@@ -0,0 +1,17 @@
+/*
+ * wxButton.hpp
+ *
+ *  Created on: 20.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXBUTTON_HPP_
+#define WXBUTTON_HPP_
+
+#include "wxAnyButton.hpp"
+
+extern VALUE rb_cWXButton;
+
+void Init_WXButton(VALUE rb_mWX);
+
+#endif /* WXBUTTON_HPP_ */

data/ext/wxButtonToolBar.cpp

@@ -0,0 +1,54 @@
+/*
+ * wxButtonToolBar.cpp
+ *
+ *  Created on: 06.12.2013
+ *      Author: hanmac
+ */
+
+
+#include "wxButtonToolBar.hpp"
+#include "wxToolBarBase.hpp"
+
+VALUE rb_cWXButtonToolBar;
+
+#if defined(__WXMAC__) && wxUSE_TOOLBAR && wxUSE_BMPBUTTON
+#include <wx/generic/buttonbar.h>
+#define _self unwrap<wxButtonToolBar*>(self)
+
+namespace RubyWX {
+namespace ButtonToolBar {
+
+APP_PROTECT(wxButtonToolBar)
+
+DLL_LOCAL VALUE _initialize(int argc,VALUE *argv,VALUE self)
+{
+	VALUE parent,name,hash;
+	rb_scan_args(argc, argv, "11:",&parent,&name,&hash);
+	if(!rb_obj_is_kind_of(name,rb_cString)){
+		_self->Create(unwrap<wxWindow*>(parent),wxID_ANY);
+		
+	}
+	rb_call_super(argc,argv);
+	return self;
+
+}
+
+}
+}
+
+#endif
+
+DLL_LOCAL void Init_WXButtonToolBar(VALUE rb_mWX)
+{
+#if defined(__WXMAC__) && wxUSE_TOOLBAR && wxUSE_BMPBUTTON
+	using namespace RubyWX::ButtonToolBar;
+	rb_cWXButtonToolBar = rb_define_class_under(rb_mWX,"ButtonToolBar",rb_cWXToolBarBase);
+	rb_define_alloc_func(rb_cWXButtonToolBar,_alloc);
+
+	rb_define_method(rb_cWXButtonToolBar,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	registerInfo<wxButtonToolBar>(rb_cWXButtonToolBar);
+#endif
+}
+
+

data/ext/wxButtonToolBar.hpp

@@ -0,0 +1,21 @@
+/*
+ * wxToolBar.hpp
+ *
+ *  Created on: 26.02.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXBUTTONTOOLBAR_HPP_
+#define WXBUTTONTOOLBAR_HPP_
+
+#include "main.hpp"
+
+#if defined(__WXMAC__) && wxUSE_TOOLBAR && wxUSE_BMPBUTTON
+#include <wx/generic/buttonbar.h>
+#endif
+
+extern VALUE rb_cWXButtonToolBar;
+
+void Init_WXButtonToolBar(VALUE rb_mWX);
+
+#endif /* WXBUTTONTOOLBAR_HPP_ */

data/ext/wxCalendarCtrl.cpp

@@ -0,0 +1,91 @@
+/*
+ * wxCalendarCtrl.cpp
+ *
+ *  Created on: 08.05.2012
+ *      Author: hanmac
+ */
+
+#include "wxCalendarCtrl.hpp"
+
+VALUE rb_cWXCalendarCtrl;
+
+#if wxUSE_CALENDARCTRL
+#define _self unwrap<wxCalendarCtrl*>(self)
+
+namespace RubyWX {
+namespace CalendarCtrl {
+
+APP_PROTECT(wxCalendarCtrl)
+
+/*
+ * call-seq:
+ *   CalendarCtrl.new(parent, name, [options])
+ *   CalendarCtrl.new(parent, [options])
+ *
+ * creates a new CalendarCtrl 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:
+ *   * date Time
+ *
+*/
+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);
+		wxDateTime date(wxDefaultDateTime);
+		int style(wxCAL_SHOW_HOLIDAYS);
+
+		if(rb_obj_is_kind_of(hash,rb_cHash)) {
+			set_hash_option(hash,"id",id,unwrapID);
+			set_hash_option(hash,"date",date);
+			set_hash_option(hash,"style",style);
+		}
+
+		_self->Create(
+			unwrap<wxWindow*>(parent),id,date,
+			wxDefaultPosition,wxDefaultSize,
+			style
+		);
+
+	}
+
+	rb_call_super(argc,argv);
+
+	if(rb_obj_is_kind_of(name,rb_cString) &&
+		rb_obj_is_kind_of(hash,rb_cHash))
+	{
+		VALUE temp;
+		set_option(date,Date,wxDateTime)
+	}
+	return self;
+}
+
+
+}
+}
+#endif
+DLL_LOCAL void Init_WXCalendarCtrl(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_cWXCalendarCtrlBase = rb_define_class_under(rb_mWX,"CalendarCtrlBase",rb_cWXControl);
+#endif
+#if wxUSE_CALENDARCTRL
+	using namespace RubyWX::CalendarCtrl;
+	rb_cWXCalendarCtrl = rb_define_class_under(rb_mWX,"CalendarCtrl",rb_cWXCalendarCtrlBase);
+	rb_define_alloc_func(rb_cWXCalendarCtrl,_alloc);
+
+	rb_define_method(rb_cWXCalendarCtrl,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	registerInfo<wxCalendarCtrl>(rb_cWXCalendarCtrl);
+#endif
+
+}

data/ext/wxCalendarCtrl.hpp

@@ -0,0 +1,17 @@
+/*
+ * wxCalendarCtrl.hpp
+ *
+ *  Created on: 08.05.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXCALENDARCTRL_HPP_
+#define WXCALENDARCTRL_HPP_
+
+#include "wxCalendarCtrlBase.hpp"
+
+extern VALUE rb_cWXCalendarCtrl;
+
+void Init_WXCalendarCtrl(VALUE rb_mWX);
+
+#endif /* WXCALENDARCTRL_HPP_ */

data/ext/wxCalendarCtrlBase.cpp

@@ -0,0 +1,55 @@
+/*
+ * wxCalendarCtrlBase.cpp
+ *
+ *  Created on: 08.05.2012
+ *      Author: hanmac
+ */
+
+#include "wxCalendarCtrlBase.hpp"
+
+VALUE rb_cWXCalendarCtrlBase;
+
+#if wxUSE_CALENDARCTRL
+#define _self unwrap<wxCalendarCtrlBase*>(self)
+
+template <>
+wxCalendarCtrlBase* unwrap<wxCalendarCtrlBase*>(const VALUE &arg)
+{
+	return unwrapTypedPtr<wxCalendarCtrlBase>(arg,rb_cWXCalendarCtrlBase);
+}
+
+namespace RubyWX {
+namespace CalendarCtrlBase {
+
+macro_attr(Date,wxDateTime)
+
+}
+}
+#endif
+
+
+/* Document-attr: date
+ * the date of the CalendarCtrl. Time
+ */
+DLL_LOCAL void Init_WXCalendarCtrlBase(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_cWXCalendarCtrlBase,"date",1,1);
+#endif
+
+#if wxUSE_CALENDARCTRL
+	using namespace RubyWX::CalendarCtrlBase;
+	rb_cWXCalendarCtrlBase = rb_define_class_under(rb_mWX,"CalendarCtrlBase",rb_cWXControl);
+	rb_undef_alloc_func(rb_cWXCalendarCtrlBase);
+
+	rb_define_attr_method(rb_cWXCalendarCtrlBase,"date",_getDate,_setDate);
+
+	registerType<wxCalendarCtrlBase>(rb_cWXCalendarCtrlBase);
+#endif
+
+}

data/ext/wxCalendarCtrlBase.hpp

@@ -0,0 +1,26 @@
+/*
+ * wxCalendarCtrlBase.hpp
+ *
+ *  Created on: 08.05.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXCALENDARCTRLBASE_HPP_
+#define WXCALENDARCTRLBASE_HPP_
+
+
+#include "wxControl.hpp"
+
+extern VALUE rb_cWXCalendarCtrlBase;
+
+void Init_WXCalendarCtrlBase(VALUE rb_mWX);
+
+#if wxUSE_CALENDARCTRL
+#include <wx/calctrl.h>
+
+template <>
+wxCalendarCtrlBase* unwrap<wxCalendarCtrlBase*>(const VALUE &arg);
+
+#endif
+
+#endif /* WXCALENDARCTRLBASE_HPP_ */

data/ext/wxCalendarCtrlGeneric.cpp

@@ -0,0 +1,102 @@
+/*
+ * wxCalendarCtrlGeneric.cpp
+ *
+ *  Created on: 08.05.2012
+ *      Author: hanmac
+ */
+#include "wxCalendarCtrlGeneric.hpp"
+#include "wxCalendarCtrl.hpp"
+
+VALUE rb_cWXCalendarCtrlGeneric;
+
+#ifdef wxHAS_NATIVE_CALENDARCTRL
+
+#define _self unwrap<wxGenericCalendarCtrl*>(self)
+
+namespace RubyWX {
+namespace GenericCalendarCtrl {
+
+APP_PROTECT(wxGenericCalendarCtrl)
+
+/*
+ * call-seq:
+ *   CalendarCtrlGeneric.new(parent, name, [options])
+ *   CalendarCtrlGeneric.new(parent, [options])
+ *
+ * creates a new CalendarCtrlGeneric 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:
+ *   * date Time
+ *
+*/
+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);
+		wxDateTime date(wxDefaultDateTime);
+		int style(wxCAL_SHOW_HOLIDAYS);
+
+		if(rb_obj_is_kind_of(hash,rb_cHash)) {
+			set_hash_option(hash,"id",id,unwrapID);
+			set_hash_option(hash,"date",date);
+			set_hash_option(hash,"style",style);
+		}
+
+		_self->Create(
+			unwrap<wxWindow*>(parent),id,date,
+			wxDefaultPosition,wxDefaultSize,
+			style
+		);
+
+	}
+
+	rb_call_super(argc,argv);
+
+	if(rb_obj_is_kind_of(name,rb_cString) &&
+		rb_obj_is_kind_of(hash,rb_cHash))
+	{
+		VALUE temp;
+		set_option(date,Date,wxDateTime)
+	}
+	return self;
+}
+
+
+
+}
+}
+#endif
+
+DLL_LOCAL void Init_WXCalendarCtrlGeneric(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_cWXCalendarCtrlBase = rb_define_class_under(rb_mWX,"CalendarCtrlBase",rb_cWXControl);
+#endif
+#if wxUSE_CALENDARCTRL
+#ifdef wxHAS_NATIVE_CALENDARCTRL
+	using namespace RubyWX::GenericCalendarCtrl;
+	rb_cWXCalendarCtrlGeneric = rb_define_class_under(rb_mWX,"CalendarCtrlGeneric",rb_cWXCalendarCtrlBase);
+	rb_define_alloc_func(rb_cWXCalendarCtrlGeneric,_alloc);
+
+	rb_define_method(rb_cWXCalendarCtrlGeneric,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	registerInfo<wxGenericCalendarCtrl>(rb_cWXCalendarCtrlGeneric);
+#else
+	rb_define_const(rb_mWX,"CalendarCtrlGeneric",rb_cWXCalendarCtrl);
+#endif
+#endif
+
+}
+
+
+
+

data/ext/wxCalendarCtrlGeneric.hpp

@@ -0,0 +1,21 @@
+/*
+ * wxCalendarCtrlGeneric.hpp
+ *
+ *  Created on: 08.05.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXCALENDARCTRLGENERIC_HPP_
+#define WXCALENDARCTRLGENERIC_HPP_
+
+#include "wxCalendarCtrlBase.hpp"
+
+extern VALUE rb_cWXCalendarCtrlGeneric;
+
+void Init_WXCalendarCtrlGeneric(VALUE rb_mWX);
+
+#if wxUSE_CALENDARCTRL
+#include <wx/generic/calctrlg.h>
+#endif
+
+#endif /* WXCALENDARCTRLGENERIC_HPP_ */

data/ext/wxCheckBox.cpp

@@ -0,0 +1,157 @@
+/*
+ * wxCheckBox.cpp
+ *
+ *  Created on: 01.05.2012
+ *      Author: hanmac
+ */
+
+
+#include "wxControl.hpp"
+
+VALUE rb_cWXCheckBox;
+
+#if wxUSE_CHECKBOX
+#define _self unwrap<wxCheckBox*>(self)
+
+namespace RubyWX {
+namespace CheckBox {
+
+macro_attr(Value,bool)
+macro_attr_enum_con(3StateValue,wxCheckBoxState,Is3State)
+
+singlereturn(Is3State)
+singlereturn(Is3rdStateAllowedForUser)
+
+APP_PROTECT(wxCheckBox)
+
+/*
+ * call-seq:
+ *   CheckBox.new(parent, name, [options])
+ *   CheckBox.new(parent, [options])
+ *
+ * creates a new CheckBox 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:
+ *   * value true/false says if this element is checked
+ *
+*/
+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);
+		wxString label(wxEmptyString);
+
+		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);
+
+			set_hash_flag_option(hash,"third_state",wxCHK_3STATE,style);
+			set_hash_flag_option(hash,"third_state_user",wxCHK_ALLOW_3RD_STATE_FOR_USER,style);
+
+			//add wxCHK_3STATE style if for user is used
+			if((style & wxCHK_ALLOW_3RD_STATE_FOR_USER) != 0)
+			{
+				style |= wxCHK_3STATE;
+			}
+
+		}
+
+		_self->Create(unwrap<wxWindow*>(parent),id,label,wxDefaultPosition,wxDefaultSize,style);
+	}
+	
+	rb_call_super(argc,argv);
+
+	if(rb_obj_is_kind_of(hash,rb_cHash))
+	{
+		VALUE temp;
+		set_option(value,Value,bool)
+	}
+
+	return self;
+}
+
+}
+}
+#endif
+
+
+/* Document-method: third_state?
+ * call-seq:
+ *   third_state? -> true/false
+ *
+ * Returns whether or not the checkbox is a 3-state checkbox.
+ * ===Return value
+ * true/false
+*/
+/* Document-method: third_state_user?
+ * call-seq:
+ *   third_state_user? -> true/false
+ *
+ * Returns whether or not the user can set the checkbox to the third state.
+ * ===Return value
+ * true/false
+*/
+
+/* Document-attr: value
+ * the value of the CheckBox. bool
+ */
+/* Document-attr: third_state
+ * the value of the CheckBox then third-state is used. Symbol
+ */
+
+/* Document-const: THIRD_STATE
+ *   Create a 3-state checkbox.
+ */
+/* Document-const: THIRD_STATE_USER
+ *   Using this flags allows the user to set the checkbox to the third state by clicking.
+ */
+DLL_LOCAL void Init_WXCheckBox(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_cWXCheckBox,"value",1,1);
+	rb_define_attr(rb_cWXCheckBox,"third_state",1,1);
+#endif
+
+#if wxUSE_CHECKBOX
+	using namespace RubyWX::CheckBox;
+	rb_cWXCheckBox = rb_define_class_under(rb_mWX,"CheckBox",rb_cWXControl);
+	rb_define_alloc_func(rb_cWXCheckBox,_alloc);
+
+	rb_define_method(rb_cWXCheckBox,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_attr_method(rb_cWXCheckBox,"value",_getValue,_setValue);
+	rb_define_attr_method(rb_cWXCheckBox,"third_state",_get3StateValue,_set3StateValue);
+
+	rb_define_method(rb_cWXCheckBox,"third_state?",RUBY_METHOD_FUNC(_Is3State),0);
+	rb_define_method(rb_cWXCheckBox,"third_state_user?",RUBY_METHOD_FUNC(_Is3rdStateAllowedForUser),0);
+
+	rb_define_const(rb_cWXCheckBox,"THIRD_STATE",INT2NUM(wxCHK_3STATE));
+	rb_define_const(rb_cWXCheckBox,"THIRD_STATE_USER",INT2NUM(wxCHK_ALLOW_3RD_STATE_FOR_USER));
+
+	registerInfo<wxCheckBox>(rb_cWXCheckBox);
+	registerEventType("checkbox",wxEVT_CHECKBOX);
+
+	registerEnum<wxCheckBoxState>("wxCheckBoxState")
+		->add(wxCHK_UNCHECKED,"unchecked")
+		->add(wxCHK_CHECKED,"checked")
+		->add(wxCHK_UNDETERMINED,"undetermined");
+
+#endif
+
+}
+