rwx 0.0.1.dev

data/ext/wxTextEntry.hpp

@@ -0,0 +1,19 @@
+/*
+ * wxtextEntry.hpp
+ *
+ *  Created on: 28.04.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXTEXTENTRY_HPP_
+#define WXTEXTENTRY_HPP_
+
+#include "main.hpp"
+
+extern VALUE rb_mWXTextEntry;
+
+void Init_WXTextEntry(VALUE rb_mWX);
+
+#include <wx/textentry.h>
+
+#endif /* WXTEXTENTRY_HPP_ */

data/ext/wxTextEntryDialog.cpp

@@ -0,0 +1,133 @@
+/*
+ * wxTextEntryDialog.cpp
+ *
+ *  Created on: 24.12.2013
+ *      Author: hanmac
+ */
+
+
+#include "wxTextEntryDialog.hpp"
+#include "wxPoint.hpp"
+#include "wxApp.hpp"
+
+VALUE rb_cWXTextEntryDialog;
+#if wxUSE_TEXTDLG
+#define _self unwrap<wxTextEntryDialog*>(self)
+
+namespace RubyWX {
+namespace TextEntryDialog {
+
+APP_PROTECT(wxTextEntryDialog)
+
+macro_attr(Value,wxString)
+
+/*
+ * call-seq:
+ *   TextEntryDialog.new(parent, name, [options])
+ *   TextEntryDialog.new(parent, [options])
+ *
+ * creates a new TextEntryDialog 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:
+ *   * path String default path
+ *   * 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(name,rb_cString))
+	{
+		wxString message(wxEmptyString);
+		wxString caption(wxGetTextFromUserPromptStr);
+		wxString value(wxEmptyString);
+		int style(wxTextEntryDialogStyle);
+
+		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,"value",value);
+
+			set_hash_option(hash,"style",style);
+
+			TopLevel::set_style_flags(hash,style);
+		}
+		_self->Create(unwrap<wxWindow*>(parent),
+				message,caption,value,style);
+		
+	}
+	rb_call_super(argc,argv);
+
+	return self;
+}
+
+DLL_LOCAL VALUE _getText(int argc,VALUE *argv,VALUE self)
+{
+	VALUE parent,hash;
+	rb_scan_args(argc, argv, "01:",&parent,&hash);
+
+	app_protected();
+
+	wxString message;
+	wxString caption(wxGetTextFromUserPromptStr);
+	wxString value;
+	wxPoint pos(wxDefaultPosition);
+	bool centre(true);
+
+	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,"value",value);
+
+		set_hash_option(hash,"pos",pos);
+		set_hash_option(hash,"center",centre);
+	}
+
+	return wrap(wxGetTextFromUser(
+		message,caption,
+		value, unwrap<wxWindow*>(parent),
+		pos.x,pos.y,centre));
+}
+
+}
+}
+
+#endif
+
+/* Document-attr: value
+ * the value of the TextEntryDialog. String
+ */
+DLL_LOCAL void Init_WXTextEntryDialog(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_define_attr(rb_cWXTextEntryDialog,"value",1,1);
+#endif
+#if wxUSE_TEXTDLG
+	using namespace RubyWX::TextEntryDialog;
+	rb_cWXTextEntryDialog = rb_define_class_under(rb_mWX,"TextEntryDialog",rb_cWXDialog);
+	rb_define_alloc_func(rb_cWXTextEntryDialog,_alloc);
+	rb_define_method(rb_cWXTextEntryDialog,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_attr_method(rb_cWXTextEntryDialog,"value",_getValue,_setValue);
+
+	rb_define_module_function(rb_mWX,"text_dialog",RUBY_METHOD_FUNC(_getText),-1);
+
+	rb_define_const(rb_cWXTextEntryDialog,"DEFAULT_STYLE",INT2NUM(wxTextEntryDialogStyle));
+
+	registerInfo<wxTextEntryDialog>(rb_cWXTextEntryDialog);
+#endif
+}

data/ext/wxTextEntryDialog.hpp

@@ -0,0 +1,20 @@
+/*
+ * wxTextEntryDialog.hpp
+ *
+ *  Created on: 24.12.2013
+ *      Author: hanmac
+ */
+
+#ifndef WXTEXTENTRYDIALOG_HPP_
+#define WXTEXTENTRYDIALOG_HPP_
+
+#include "wxDialog.hpp"
+
+extern VALUE rb_cWXTextEntryDialog;
+
+void Init_WXTextEntryDialog(VALUE rb_mWX);
+#if wxUSE_TEXTDLG
+#include <wx/textdlg.h>
+#endif
+
+#endif /* WXTEXTENTRYDIALOG_HPP_ */

data/ext/wxTimePicker.cpp

@@ -0,0 +1,105 @@
+/*
+ * wxTimePickerCtrl.cpp
+ *
+ *  Created on: 02.03.2012
+ *      Author: hanmac
+ */
+
+
+#include "wxTimePicker.hpp"
+#include "wxControl.hpp"
+
+VALUE rb_cWXTimePicker;
+
+#if wxUSE_TIMEPICKCTRL
+#define _self unwrap<wxTimePickerCtrl*>(self)
+
+namespace RubyWX {
+namespace TimePicker {
+
+macro_attr(Value,wxDateTime)
+
+APP_PROTECT(wxTimePickerCtrl)
+
+/*
+ * call-seq:
+ *   TimePicker.new(parent, name, [options])
+ *   TimePicker.new(parent, [options])
+ *
+ * creates a new TimePicker 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);
+		wxDateTime date(wxDefaultDateTime);
+		int style(wxTP_DEFAULT);
+
+		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,Value,wxDateTime)
+	}
+	
+	rb_call_super(argc,argv);
+	return self;
+}
+
+}
+}
+#endif
+
+/* Document-attr: value
+ * the value of the TimePicker. Time
+ */
+DLL_LOCAL void Init_WXTimePicker(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_cWXTimePicker,"value",1,1);
+#endif
+
+#if wxUSE_TIMEPICKCTRL
+	using namespace RubyWX::TimePicker;
+	rb_cWXTimePicker = rb_define_class_under(rb_mWX,"TimePicker",rb_cWXControl);
+	rb_define_alloc_func(rb_cWXTimePicker,_alloc);
+
+	rb_define_method(rb_cWXTimePicker,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_attr_method(rb_cWXTimePicker,"value",_getValue,_setValue);
+
+	registerInfo<wxTimePickerCtrl>(rb_cWXTimePicker);
+#endif
+
+}
+
+

data/ext/wxTimePicker.hpp

@@ -0,0 +1,22 @@
+/*
+ * wxTimePickerCtrl.hpp
+ *
+ *  Created on: 02.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXTIMEPICKER_HPP_
+#define WXTIMEPICKER_HPP_
+
+
+#include "wxControl.hpp"
+
+extern VALUE rb_cWXTimePicker;
+
+void Init_WXTimePicker(VALUE rb_mWX);
+
+#if wxUSE_TIMEPICKCTRL
+#include <wx/timectrl.h>
+#endif
+
+#endif /* WXTIMEPICKER_HPP_ */

data/ext/wxTimer.cpp

@@ -0,0 +1,106 @@
+/*
+ * wxTimer.cpp
+ *
+ *  Created on: 11.03.2012
+ *      Author: hanmac
+ */
+
+#include "wxEvtHandler.hpp"
+#include "wxTimer.hpp"
+#include "wxApp.hpp"
+
+VALUE rb_cWXTimer,rb_cWXTimerEvent;
+#if wxUSE_TIMER
+#define _self unwrap<wxTimer*>(self)
+
+namespace RubyWX {
+namespace Timer {
+
+APP_PROTECT(wxTimer)
+
+DLL_LOCAL VALUE _initialize(VALUE self)
+{
+	if(rb_block_given_p()){
+		VALUE proc = rb_block_proc();
+
+		_self->Bind(wxEVT_TIMER,RubyFunctor(proc),_self->GetId());
+
+	}
+
+	return self;
+}
+
+DLL_LOCAL VALUE _start(VALUE self,VALUE msec)
+{
+	return wrap(_self->Start(NUM2UINT(msec)));
+}
+
+singlefunc(Stop)
+singlereturn(GetOwner)
+
+singlereturn(GetInterval)
+singlereturn(IsRunning)
+
+DLL_LOCAL VALUE _setOwner(VALUE self,VALUE val)
+{
+	_self->SetOwner(unwrap<wxEvtHandler*>(val),_self->GetId());
+	return val;
+}
+
+namespace Event {
+
+#undef _self
+#define _self unwrapTypedPtr<wxTimerEvent>(self,rb_cWXTimerEvent)
+
+singlereturn(GetInterval)
+
+}
+
+}
+}
+
+#endif
+
+
+
+DLL_LOCAL void Init_WXTimer(VALUE rb_mWX)
+{
+#if 0
+	rb_define_attr(rb_cWXTimer,"owner",1,1);
+
+	rb_mWXEvtHandler = rb_define_module_under(rb_mWX,"EvtHandler");
+#endif
+
+#if wxUSE_TIMER
+	using namespace RubyWX::Timer;
+
+	rb_cWXTimer = rb_define_class_under(rb_mWX,"Timer",rb_cObject);
+	rb_define_alloc_func(rb_cWXTimer,_alloc);
+
+	rb_undef_method(rb_cWXTimer,"initialize_copy");
+	rb_undef_method(rb_cWXTimer,"_load");
+	rb_undef_method(rb_cWXTimer,"_dump");
+
+	rb_define_method(rb_cWXTimer,"initialize",RUBY_METHOD_FUNC(_initialize),0);
+
+	rb_include_module(rb_cWXTimer,rb_mWXEvtHandler);
+
+	rb_define_method(rb_cWXTimer,"start",RUBY_METHOD_FUNC(_start),1);
+	rb_define_method(rb_cWXTimer,"stop",RUBY_METHOD_FUNC(_Stop),0);
+
+	rb_define_method(rb_cWXTimer,"running?",RUBY_METHOD_FUNC(_IsRunning),0);
+
+	rb_define_method(rb_cWXTimer,"interval",RUBY_METHOD_FUNC(_GetInterval),0);
+
+	rb_define_attr_method(rb_cWXTimer,"owner",_GetOwner,_setOwner);
+
+	rb_cWXTimerEvent = rb_define_class_under(rb_cWXEvent,"Timer",rb_cWXEvent);
+
+	rb_define_method(rb_cWXTimerEvent,"interval",RUBY_METHOD_FUNC(Event::_GetInterval),0);
+
+	registerEventType("timer",wxEVT_TIMER,rb_cWXTimerEvent);
+
+	registerInfo<wxTimer>(rb_cWXTimer);
+#endif
+}
+

data/ext/wxTimer.hpp

@@ -0,0 +1,16 @@
+/*
+ * wxTimer.hpp
+ *
+ *  Created on: 11.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXTIMER_HPP_
+#define WXTIMER_HPP_
+
+#include "main.hpp"
+
+extern VALUE rb_cWXTimer;
+DLL_LOCAL void Init_WXTimer(VALUE rb_mWX);
+
+#endif /* WXTIMER_HPP_ */

data/ext/wxToggleButton.cpp

@@ -0,0 +1,96 @@
+/*
+ * wxToggleButton.cpp
+ *
+ *  Created on: 10.12.2013
+ *      Author: hanmac
+ */
+
+#include "wxToggleButton.hpp"
+
+VALUE rb_cWXToggleButton;
+#if wxUSE_TOGGLEBTN
+#define _self unwrap<wxToggleButton*>(self)
+
+namespace RubyWX {
+namespace ToggleButton {
+
+APP_PROTECT(wxToggleButton)
+
+macro_attr(Value,bool)
+
+/*
+ * call-seq:
+ *   ToggleButton.new(parent, name, [options])
+ *   ToggleButton.new(parent, [options])
+ *
+ * creates a new ToggleButton 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
+ *
+*/
+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);
+
+	if(rb_obj_is_kind_of(hash,rb_cHash)) {
+		VALUE temp;
+		set_option(id,Value,bool);
+	}
+
+	return self;
+}
+
+}
+}
+
+#endif
+
+/* Document-attr: value
+ * the value of the ToggleButton. bool
+ */
+DLL_LOCAL void Init_WXToggleButton(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_cWXToggleButton,"value",1,1);
+#endif
+
+#if wxUSE_TOGGLEBTN
+	using namespace RubyWX::ToggleButton;
+	rb_cWXToggleButton = rb_define_class_under(rb_mWX,"ToggleButton",rb_cWXAnyButton);
+	rb_define_alloc_func(rb_cWXToggleButton,_alloc);
+
+	rb_define_method(rb_cWXToggleButton,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_attr_method(rb_cWXToggleButton,"value",_getValue,_setValue);
+
+	registerInfo<wxToggleButton>(rb_cWXToggleButton);
+
+	registerEventType<wxCommandEvent>("toogle_button",wxEVT_TOGGLEBUTTON);
+
+#endif
+}