rwx 0.0.1.dev

data/ext/wxMultiChoiceDialog.hpp

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

data/ext/wxNoteBook.cpp

@@ -0,0 +1,89 @@
+/*
+ * wxNoteBook.cpp
+ *
+ *  Created on: 30.03.2012
+ *      Author: hanmac
+ */
+
+#include "wxNoteBook.hpp"
+#include "wxBookCtrl.hpp"
+
+VALUE rb_cWXNotebook;
+
+#if wxUSE_NOTEBOOK
+#define _self unwrap<wxNotebook*>(self)
+
+namespace RubyWX {
+namespace Notebook {
+
+APP_PROTECT(wxNotebook)
+
+/*
+ * call-seq:
+ *   NoteBookCtrl.new(parent, name, [options])
+ *   NoteBookCtrl.new(parent, [options])
+ *
+ * creates a new NoteBookCtrl 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_WXNoteBookCtrl(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_NOTEBOOK
+	using namespace RubyWX::Notebook;
+	rb_cWXNotebook = rb_define_class_under(rb_mWX,"NoteBookCtrl",rb_cWXBookCtrlBase);
+	rb_define_alloc_func(rb_cWXNotebook,_alloc);
+
+	rb_define_method(rb_cWXNotebook,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	registerInfo<wxNotebook>(rb_cWXNotebook);
+
+	registerEventType<wxBookCtrlEvent>("notebook_page_changed",wxEVT_NOTEBOOK_PAGE_CHANGED);
+	registerEventType<wxBookCtrlEvent>("notebook_page_changing",wxEVT_NOTEBOOK_PAGE_CHANGING);
+#endif
+
+}
+
+
+
+
+

data/ext/wxNoteBook.hpp

@@ -0,0 +1,21 @@
+/*
+ * wxNotebook.hpp
+ *
+ *  Created on: 30.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXNOTEBOOK_HPP_
+#define WXNOTEBOOK_HPP_
+
+#include "wxEvtHandler.hpp"
+
+extern VALUE rb_cWXNotebook;
+
+void Init_WXNoteBookCtrl(VALUE rb_mWX);
+
+#if wxUSE_NOTEBOOK
+#include <wx/notebook.h>
+#endif
+
+#endif /* WXNOTEBOOK_HPP_ */

data/ext/wxNotifyEvent.cpp

@@ -0,0 +1,45 @@
+/*
+ * wxNotifyEvent.cpp
+ *
+ *  Created on: 08.11.2012
+ *      Author: hanmac
+ */
+
+#include "wxEvent.hpp"
+#include "wxWindow.hpp"
+
+#define _self unwrap<wxNotifyEvent*>(self)
+
+VALUE rb_cWXNotifyEvent;
+
+namespace RubyWX {
+namespace NotifyEvent {
+
+singlefunc(IsAllowed)
+singlefunc(Allow)
+singlefunc(Veto)
+
+}
+}
+
+
+DLL_LOCAL void Init_WXNotifyEvent(VALUE rb_mWX)
+{
+#if 0
+	rb_mWX = rb_define_module("WX");
+	rb_cWXEvent = rb_define_class_under(rb_mWX,"Event",rb_cObject);
+	rb_cWXCommandEvent = rb_define_class_under(rb_cWXEvent,"Command",rb_cWXEvent);
+#endif
+
+	using namespace RubyWX::NotifyEvent;
+
+	rb_cWXNotifyEvent = rb_define_class_under(rb_cWXEvent,"Notify",rb_cWXCommandEvent);
+
+	rb_define_method(rb_cWXNotifyEvent,"allowed?",RUBY_METHOD_FUNC(_IsAllowed),0);
+	rb_define_method(rb_cWXNotifyEvent,"allow",RUBY_METHOD_FUNC(_Allow),0);
+	rb_define_method(rb_cWXNotifyEvent,"veto",RUBY_METHOD_FUNC(_Veto),0);
+
+	registerInfo<wxNotifyEvent>(rb_cWXNotifyEvent);
+}
+
+

data/ext/wxNotifyEvent.hpp

@@ -0,0 +1,16 @@
+/*
+ * wxNotifyEvent.hpp
+ *
+ *  Created on: 15.11.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXNOTIFYEVENT_HPP_
+#define WXNOTIFYEVENT_HPP_
+
+#include "main.hpp"
+
+extern VALUE rb_cWXNotifyEvent;
+void Init_WXNotifyEvent(VALUE rb_mWX);
+
+#endif /* WXNOTIFYEVENT_HPP_ */

data/ext/wxNumberEntryDialog.cpp

@@ -0,0 +1,131 @@
+/*
+ * wxNumberEntryDialog.cpp
+ *
+ *  Created on: 24.12.2013
+ *      Author: hanmac
+ */
+
+
+#include "wxNumberEntryDialog.hpp"
+#include "wxPoint.hpp"
+#include "wxApp.hpp"
+
+VALUE rb_cWXNumberEntryDialog;
+#if wxUSE_NUMBERDLG
+#define _self unwrap<wxNumberEntryDialog*>(self)
+
+namespace RubyWX {
+namespace NumberEntryDialog {
+
+#ifdef HAVE_WXNUMBERENTRYDIALOG
+APP_PROTECT(wxNumberEntryDialog)
+#else
+APP_PROTECT_NULL
+#endif
+
+singlereturn(GetValue)
+
+/*
+ * call-seq:
+ *   NumberEntryDialog.new(parent, name, [options])
+ *   NumberEntryDialog.new(parent, [options])
+ *
+ * creates a new NumberEntryDialog widget.
+ * ===Arguments
+ * * parent of this window or nil
+ *
+ * *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(hash,rb_cString))
+	{
+		wxString message,prompt,caption;
+		long value = 0, min = 0, max = 0;
+		if(rb_obj_is_kind_of(hash,rb_cHash))
+		{
+			set_hash_option(hash,"message",message);
+			set_hash_option(hash,"prompt",prompt);
+			set_hash_option(hash,"caption",caption);
+
+			set_hash_option(hash,"value",value);
+			set_hash_option(hash,"min",min);
+			set_hash_option(hash,"max",max);
+		}
+#ifdef HAVE_WXNUMBERENTRYDIALOG
+		_self->Create(unwrap<wxWindow*>(parent),
+				message,prompt,caption,value,min,max);
+#else
+		RTYPEDDATA_DATA(self) = new wxNumberEntryDialog(unwrap<wxWindow*>(parent),
+				message,prompt,caption,value,min,max);
+#endif
+		
+	}
+	rb_call_super(argc,argv);
+
+	return self;
+}
+
+DLL_LOCAL VALUE _getNumber(int argc,VALUE *argv,VALUE self)
+{
+	VALUE parent,hash;
+	rb_scan_args(argc, argv, "02",&parent,&hash);
+
+	app_protected();
+
+	wxString message,prompt,caption;
+	long value(0), min(0), max(100);
+	wxPoint pos(wxDefaultPosition);
+
+	if(rb_obj_is_kind_of(hash,rb_cHash))
+	{
+		set_hash_option(hash,"message",message);
+		set_hash_option(hash,"prompt",prompt);
+		set_hash_option(hash,"caption",caption);
+
+		set_hash_option(hash,"value",value);
+		set_hash_option(hash,"min",min);
+		set_hash_option(hash,"max",max);
+
+		set_hash_option(hash,"pos",pos);
+	}
+
+	return wrap(wxGetNumberFromUser(
+			message,prompt,caption,
+			value,min,max,
+			unwrap<wxWindow*>(parent),pos));
+}
+
+}
+}
+
+#endif
+
+DLL_LOCAL void Init_WXNumberEntryDialog(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_NUMBERDLG
+	using namespace RubyWX::NumberEntryDialog;
+	rb_cWXNumberEntryDialog = rb_define_class_under(rb_mWX,"NumberEntryDialog",rb_cWXDialog);
+	rb_define_alloc_func(rb_cWXNumberEntryDialog,_alloc);
+	rb_define_method(rb_cWXNumberEntryDialog,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_method(rb_cWXNumberEntryDialog,"value",RUBY_METHOD_FUNC(_GetValue),0);
+
+	rb_define_module_function(rb_mWX,"number_dialog",RUBY_METHOD_FUNC(_getNumber),-1);
+
+	registerInfo<wxNumberEntryDialog>(rb_cWXNumberEntryDialog);
+#endif
+}

data/ext/wxNumberEntryDialog.hpp

@@ -0,0 +1,20 @@
+/*
+ * wxNumberEntryDialog.hpp
+ *
+ *  Created on: 24.12.2013
+ *      Author: hanmac
+ */
+
+#ifndef WXNUMBERENTRYDIALOG_HPP_
+#define WXNUMBERENTRYDIALOG_HPP_
+
+#include "wxDialog.hpp"
+
+extern VALUE rb_cWXNumberEntryDialog;
+
+void Init_WXNumberEntryDialog(VALUE rb_mWX);
+#if wxUSE_NUMBERDLG
+#include <wx/numdlg.h>
+#endif
+
+#endif /* WXNUMBERENTRYDIALOG_HPP_ */

data/ext/wxPalette.cpp

@@ -0,0 +1,214 @@
+/*
+ * wxPalette.cpp
+ *
+ *  Created on: 20.11.2013
+ *      Author: hanmac
+ */
+
+#include "wxPalette.hpp"
+#include "wxColor.hpp"
+
+#if wxUSE_PALETTE
+
+#define _self unwrap<wxPalette*>(self)
+
+VALUE rb_cWXPalette;
+
+template <>
+wxPalette* unwrap< wxPalette* >(const VALUE &vimage)
+{
+	return unwrapTypedPtr<wxPalette>(vimage, rb_cWXPalette);
+}
+
+
+template <>
+wxPalette unwrap< wxPalette >(const VALUE &vimage)
+{
+	return *unwrap<wxPalette*>(vimage);
+}
+
+
+namespace RubyWX {
+namespace Palette {
+
+singlereturn(GetColoursCount)
+
+DLL_LOCAL VALUE _alloc(VALUE self) {
+	return wrap(new wxPalette);
+}
+
+DLL_LOCAL VALUE _initialize(int argc, VALUE *argv, VALUE self) {
+	if(argc > 0)
+	{
+		unsigned char red[argc];
+		unsigned char green[argc];
+		unsigned char blue[argc];
+		for(std::size_t i = 0; i < (std::size_t)argc; ++i)
+		{
+			wxColor temp = unwrap<wxColor>(argv[i]);
+			red[i]   = temp.Red();
+			green[i] = temp.Green();
+			blue[i]  = temp.Blue();
+		}
+
+		_self->Create(argc,red,green,blue);
+	}
+	return self;
+}
+
+DLL_LOCAL VALUE _initialize_copy(VALUE self,VALUE other) {
+	wxPalette *cother = unwrap<wxPalette*>(other);
+	std::size_t count(cother->GetColoursCount());
+
+	unsigned char red[count];
+	unsigned char green[count];
+	unsigned char blue[count];
+
+	for(std::size_t i = 0; i < count; ++i)
+	{
+		cother->GetRGB(i,&red[i],&green[i],&blue[i]);
+	}
+
+	_self->Create(count,red,green,blue);
+
+	return self;
+}
+
+/*
+ * call-seq:
+ *   image[idx] -> WX::Color or nil
+ *
+ * Returns the color at the given position or nil if out of range
+ * ===Arguments
+ * * idx is Integer
+ * ===Return value
+ * WX::Color or nil
+*/
+DLL_LOCAL VALUE _get(VALUE self,VALUE idx)
+{
+	unsigned char red,green,blue;
+	if(_self->GetRGB(NUM2UINT(idx),&red,&green,&blue))
+		return wrap(new wxColor(red,green,blue));
+	return Qnil;
+}
+
+
+/*
+ * call-seq:
+ *   each -> Enumerator
+ *   each { |color| } -> self
+ *
+ * iterates the colors in this Palette.
+ * ===Return value
+ * self
+ *
+*/
+DLL_LOCAL VALUE _each(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self,0,NULL,RUBY_METHOD_FUNC(_GetColoursCount));
+
+	unsigned char red,green,blue;
+
+	std::size_t count = _self->GetColoursCount();
+	for(std::size_t i = 0; i < count; ++i)
+	{
+		_self->GetRGB(i,&red,&green,&blue);
+		rb_yield(wrap(new wxColor(red,green,blue)));
+	}
+	return 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 ary = rb_ary_new(); //2(_self->GetColoursCount()*3);
+	std::size_t count = _self->GetColoursCount();
+	for(std::size_t i = 0; i < count; ++i)
+	{
+		unsigned char red,green,blue;
+		_self->GetRGB(i,&red,&green,&blue);
+		rb_ary_store(ary,i*3,UINT2NUM(red));
+		rb_ary_store(ary,i*3+1,UINT2NUM(green));
+		rb_ary_store(ary,i*3+2,UINT2NUM(blue));
+	}
+	return ary;
+}
+
+/*
+ * call-seq:
+ *   marshal_load(array) -> nil
+ *
+ * Provides marshalling support for use by the Marshal library.
+ *
+ *
+ */
+DLL_LOCAL VALUE _marshal_load(VALUE self,VALUE data)
+{
+	std::size_t count = RARRAY_LEN(data) / 3;
+
+	unsigned char red[count];
+	unsigned char green[count];
+	unsigned char blue[count];
+
+	for(std::size_t i = 0; i < count; ++i)
+	{
+		red[i]   = NUM2UINT(RARRAY_AREF(data,i*3));
+		green[i] = NUM2UINT(RARRAY_AREF(data,i*3+1));
+		blue[i]  = NUM2UINT(RARRAY_AREF(data,i*3+2));
+	}
+
+	_self->Create(count,red,green,blue);
+
+	return self;
+}
+
+
+
+}
+}
+
+#endif
+
+/* Document-method: size
+ * call-seq:
+ *   size -> Integer
+ *
+ * returns the count of colors in this Palette list.
+ * ===Return value
+ * Integer
+ */
+
+DLL_LOCAL void Init_WXPalette(VALUE rb_mWX)
+{
+#if wxUSE_PALETTE
+
+	using namespace RubyWX::Palette;
+	rb_cWXPalette = rb_define_class_under(rb_mWX,"Palette",rb_cObject);
+	rb_define_alloc_func(rb_cWXPalette,_alloc);
+
+	rb_include_module(rb_cWXPalette,rb_mEnumerable);
+
+	rb_define_method(rb_cWXPalette,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+	rb_define_private_method(rb_cWXPalette,"initialize_copy",RUBY_METHOD_FUNC(_initialize_copy),1);
+
+	rb_define_method(rb_cWXPalette,"[]",RUBY_METHOD_FUNC(_get),1);
+
+	rb_define_method(rb_cWXPalette,"size",RUBY_METHOD_FUNC(_GetColoursCount),0);
+	rb_define_method(rb_cWXPalette,"each",RUBY_METHOD_FUNC(_each),0);
+
+	rb_define_method(rb_cWXPalette,"marshal_dump",RUBY_METHOD_FUNC(_marshal_dump),0);
+	rb_define_method(rb_cWXPalette,"marshal_load",RUBY_METHOD_FUNC(_marshal_load),1);
+
+	registerInfo<wxPalette>(rb_cWXPalette);
+#endif
+
+}
+
+