rwx 0.0.1.dev

data/ext/wxImage.hpp

@@ -0,0 +1,24 @@
+/*
+ * wxImage.hpp
+ *
+ *  Created on: 16.02.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXIMAGE_HPP_
+#define WXIMAGE_HPP_
+
+#include "wxSize.hpp"
+
+extern VALUE rb_cWXImage;
+DLL_LOCAL void Init_WXImage(VALUE rb_mWX);
+
+#if wxUSE_IMAGE
+template <>
+wxImage* unwrap< wxImage* >(const VALUE &vimage);
+
+
+template <>
+wxImage unwrap< wxImage >(const VALUE &vimage);
+#endif
+#endif /* WXIMAGE_HPP_ */

data/ext/wxInfoBar.cpp

@@ -0,0 +1,85 @@
+/*
+ * wxInfobar.cpp
+ *
+ *  Created on: 09.03.2013
+ *      Author: hanmac
+ */
+
+#include "wxInfoBar.hpp"
+
+VALUE rb_cWXInfoBar;
+
+#if wxUSE_INFOBAR
+#define _self unwrap<wxInfoBar*>(self)
+
+namespace RubyWX {
+namespace InfoBar {
+
+APP_PROTECT(wxInfoBar)
+
+
+
+/*
+ * call-seq:
+ *   InfoBar.new(parent, name, [options])
+ *   InfoBar.new(parent, [options])
+ *
+ * creates a new InfoBar 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(NIL_P(hash))
+		name = hash;
+
+	if(!_created && !rb_obj_is_kind_of(name,rb_cString))
+	{
+		wxWindowID id(wxID_ANY);
+
+		if(rb_obj_is_kind_of(hash,rb_cHash))
+		{
+			set_hash_option(hash,"id",id,unwrapID);
+		}
+		_self->Create(unwrap<wxWindow*>(parent),id);
+
+	}
+	
+	rb_call_super(argc,argv);
+	return self;
+}
+
+
+}
+}
+#endif
+DLL_LOCAL void Init_WXInfoBar(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_cWXInfoBarBase = rb_define_class_under(rb_mWX,"InfoBarBase",rb_cWXControl);
+#endif
+
+#if wxUSE_INFOBAR
+	using namespace RubyWX::InfoBar;
+	rb_cWXInfoBar = rb_define_class_under(rb_mWX,"InfoBar",rb_cWXInfoBarBase);
+	rb_define_alloc_func(rb_cWXInfoBar,_alloc);
+
+	rb_define_method(rb_cWXInfoBar,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	registerInfo<wxInfoBar>(rb_cWXInfoBar);
+#endif
+
+}
+

data/ext/wxInfoBar.hpp

@@ -0,0 +1,21 @@
+/*
+ * wxInfoBar.hpp
+ *
+ *  Created on: 09.03.2013
+ *      Author: hanmac
+ */
+
+#ifndef WXINFOBAR_HPP_
+#define WXINFOBAR_HPP_
+
+#include "wxInfoBarBase.hpp"
+
+extern VALUE rb_cWXInfoBar;
+
+void Init_WXInfoBar(VALUE rb_mWX);
+
+#if wxUSE_INFOBAR
+#include <wx/infobar.h>
+#endif
+
+#endif /* WXINFOBAR_HPP_ */

data/ext/wxInfoBarBase.cpp

@@ -0,0 +1,145 @@
+/*
+ * wxInfobarBase.cpp
+ *
+ *  Created on: 09.03.2013
+ *      Author: hanmac
+ */
+
+
+#include "wxInfoBarBase.hpp"
+
+VALUE rb_cWXInfoBarBase;
+
+#if wxUSE_INFOBAR
+
+template <>
+wxInfoBarBase* unwrap<wxInfoBarBase*>(const VALUE &arg)
+{
+	return unwrapTypedPtr<wxInfoBarBase>(arg,rb_cWXInfoBarBase);
+}
+
+
+#define _self unwrap<wxInfoBarBase*>(self)
+
+namespace RubyWX {
+namespace InfoBarBase {
+
+singlefunc(Dismiss)
+
+DLL_LOCAL VALUE _showMessage(int argc,VALUE *argv,VALUE self)
+{
+	VALUE text,icon;
+	rb_scan_args(argc, argv, "11",&text,&icon);
+
+	//use argc for check if parameter is given because nil is treated different
+	_self->ShowMessage(unwrap<wxString>(text), argc == 1 ? wxICON_INFORMATION : unwrap_iconflag(icon));
+
+	return self;
+}
+
+DLL_LOCAL VALUE _addButton(int argc,VALUE *argv,VALUE self)
+{
+	VALUE id,label;
+	rb_scan_args(argc, argv, "11",&id,&label);
+	
+	wxWindowID wid = unwrapID(id);
+	
+	_self->AddButton(wid,unwrap<wxString>(label));
+	
+	if(rb_block_given_p())
+	{
+		VALUE proc = rb_block_proc();
+
+		_self->Bind(wxEVT_BUTTON,RubyFunctor(proc),wid);
+	
+	}
+	return self;
+}
+
+DLL_LOCAL VALUE _removeButton(VALUE self,VALUE id)
+{
+	wxWindowID wid = unwrapID(id);
+
+#ifdef HAVE_WXINFOBAR_GETBUTTONCOUNT
+	if(!_self->HasButtonId(wid))
+		return Qnil;
+#endif
+
+	_self->RemoveButton(wid);
+	return self;
+}
+
+#ifdef HAVE_WXINFOBAR_GETBUTTONCOUNT
+
+DLL_LOCAL VALUE _hasButton(VALUE self,VALUE id)
+{
+	return wrap(_self->HasButtonId(unwrapID(id)));
+}
+
+DLL_LOCAL VALUE _each_button_size(VALUE self)
+{
+	return UINT2NUM(_self->GetButtonCount());
+}
+
+
+DLL_LOCAL VALUE _each_button(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self,0,NULL,RUBY_METHOD_FUNC(_each_button_size));
+	
+	std::size_t count = _self->GetButtonCount();
+	
+	for(std::size_t i = 0; i < count; ++i)
+		rb_yield(wrapID(_self->GetButtonId(i)));
+	
+	return self;
+}
+
+DLL_LOCAL VALUE _getButton(VALUE self,VALUE idx)
+{
+	int cidx = NUM2INT(idx);
+	if(check_index(cidx,_self->GetButtonCount()))
+		return wrapID(_self->GetButtonId(cidx));
+	return Qnil;
+}
+
+#endif
+
+}
+}
+
+#endif
+DLL_LOCAL void Init_WXInfoBarBase(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);
+#endif
+
+#if wxUSE_INFOBAR
+	using namespace RubyWX::InfoBarBase;
+	rb_cWXInfoBarBase = rb_define_class_under(rb_mWX,"InfoBarBase",rb_cWXControl);
+	rb_undef_alloc_func(rb_cWXInfoBarBase);
+
+	rb_define_method(rb_cWXInfoBarBase,"dismiss",RUBY_METHOD_FUNC(_Dismiss),0);
+	rb_define_method(rb_cWXInfoBarBase,"show_message",RUBY_METHOD_FUNC(_showMessage),-1);
+
+	rb_define_method(rb_cWXInfoBarBase,"add_button",RUBY_METHOD_FUNC(_addButton),-1);
+	rb_define_method(rb_cWXInfoBarBase,"remove_button",RUBY_METHOD_FUNC(_removeButton),1);
+
+#ifdef HAVE_WXINFOBAR_GETBUTTONCOUNT
+
+	rb_define_method(rb_cWXInfoBarBase,"has_button?",RUBY_METHOD_FUNC(_hasButton),1);
+	rb_define_method(rb_cWXInfoBarBase,"get_button",RUBY_METHOD_FUNC(_getButton),1);
+
+	rb_define_method(rb_cWXInfoBarBase,"each_button",RUBY_METHOD_FUNC(_each_button),0);
+
+#endif
+
+	registerType<wxInfoBarBase>(rb_cWXInfoBarBase);
+#endif
+
+}
+
+

data/ext/wxInfoBarBase.hpp

@@ -0,0 +1,21 @@
+/*
+ * wxInfobarBase.hpp
+ *
+ *  Created on: 09.03.2013
+ *      Author: hanmac
+ */
+
+#ifndef WXINFOBARBASE_HPP_
+#define WXINFOBARBASE_HPP_
+
+#include "wxControl.hpp"
+
+extern VALUE rb_cWXInfoBarBase;
+
+void Init_WXInfoBarBase(VALUE rb_mWX);
+
+#if wxUSE_INFOBAR
+#include <wx/infobar.h>
+#endif
+
+#endif /* WXINFOBARBASE_HPP_ */

data/ext/wxInfoBarGeneric.cpp

@@ -0,0 +1,90 @@
+/*
+ * wxInfoBarGeneric.cpp
+ *
+ *  Created on: 09.03.2013
+ *      Author: hanmac
+ */
+
+#include "wxInfoBarGeneric.hpp"
+#include "wxInfoBar.hpp"
+
+VALUE rb_cWXInfoBarGeneric;
+
+#if wxUSE_INFOBAR && defined(wxHAS_NATIVE_INFOBAR)
+#define _self unwrap<wxInfoBarGeneric*>(self)
+
+namespace RubyWX {
+namespace GenericInfoBar {
+
+APP_PROTECT(wxInfoBarGeneric)
+
+/*
+ * call-seq:
+ *   InfoBarGeneric.new(parent, name, [options])
+ *   InfoBarGeneric.new(parent, [options])
+ *
+ * creates a new InfoBarGeneric 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(NIL_P(hash))
+		name = hash;
+
+	if(!_created && !rb_obj_is_kind_of(name,rb_cString))
+	{
+		wxWindowID id(wxID_ANY);
+
+		if(rb_obj_is_kind_of(hash,rb_cHash))
+		{
+			set_hash_option(hash,"id",id,unwrapID);
+		}
+		_self->Create(unwrap<wxWindow*>(parent),id);
+
+	}
+	
+	rb_call_super(argc,argv);
+	return self;
+}
+
+
+}
+}
+#endif
+DLL_LOCAL void Init_WXInfoBarGeneric(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_cWXInfoBarBase = rb_define_class_under(rb_mWX,"InfoBarBase",rb_cWXControl);
+#endif
+
+#if wxUSE_INFOBAR
+#ifdef wxHAS_NATIVE_INFOBAR
+	using namespace RubyWX::GenericInfoBar;
+	rb_cWXInfoBarGeneric = rb_define_class_under(rb_mWX,"InfoBarGeneric",rb_cWXInfoBarBase);
+	rb_define_alloc_func(rb_cWXInfoBarGeneric,_alloc);
+
+	rb_define_method(rb_cWXInfoBarGeneric,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	registerInfo<wxInfoBarGeneric>(rb_cWXInfoBarGeneric);
+#else
+	rb_define_const(rb_mWX,"InfoBarGeneric",rb_cWXInfoBar);
+#endif
+#endif
+
+}
+
+
+

data/ext/wxInfoBarGeneric.hpp

@@ -0,0 +1,21 @@
+/*
+ * wxInfoBarGeneric.hpp
+ *
+ *  Created on: 09.03.2013
+ *      Author: hanmac
+ */
+
+#ifndef WXINFOBARGENERIC_HPP_
+#define WXINFOBARGENERIC_HPP_
+
+#include "wxInfoBarBase.hpp"
+
+extern VALUE rb_cWXInfoBarGeneric;
+
+void Init_WXInfoBarGeneric(VALUE rb_mWX);
+
+#if wxUSE_INFOBAR
+#include <wx/generic/infobar.h>
+#endif
+
+#endif /* WXINFOBARGENERIC_HPP_ */

data/ext/wxItemContainer.cpp

@@ -0,0 +1,313 @@
+/*
+ * wxItemContainer.cpp
+ *
+ *  Created on: 03.05.2012
+ *      Author: hanmac
+ */
+
+
+#include "wxItemContainer.hpp"
+
+#include "wxListBox.hpp"
+#include "wxChoice.hpp"
+#include "wxBitmapComboBox.hpp"
+#include "wxComboBox.hpp"
+
+VALUE rb_mWXItemContainer;
+#if wxUSE_CONTROLS
+
+//otherwise the casting is wrong
+template <>
+wxItemContainer* unwrap< wxItemContainer* >(const VALUE &obj)
+{
+#if wxUSE_LISTBOX
+	if(rb_obj_is_kind_of(obj,rb_cWXListBox))
+		return unwrap<wxListBox*>(obj);
+#endif
+#if wxUSE_CHOICE
+	if(rb_obj_is_kind_of(obj,rb_cWXChoice))
+		return unwrap<wxChoice*>(obj);
+#endif
+#if wxUSE_BITMAPCOMBOBOX
+	if(rb_obj_is_kind_of(obj,rb_cWXBitmapComboBox))
+		return unwrap<wxBitmapComboBox*>(obj);
+#endif
+#if wxUSE_COMBOBOX
+	if(rb_obj_is_kind_of(obj,rb_cWXComboBox))
+		return unwrap<wxComboBox*>(obj);
+#endif
+		return unwrapTypedPtr<wxItemContainer>(obj,rb_mWXItemContainer);
+ return NULL;
+}
+
+#define _self unwrap<wxItemContainer*>(self)
+
+namespace RubyWX {
+namespace ItemContainer {
+
+macro_attr_selection(Selection,GetCount)
+macro_attr(StringSelection,wxString)
+
+singlefunc(Clear)
+
+singlereturn(GetCount)
+singlereturn(IsSorted)
+singlereturn(IsEmpty)
+singlereturn(GetStrings)
+
+
+
+/*
+ * call-seq:
+ *   each_item -> Enumerator
+ *   each_item { | text| } -> self
+ *
+ * iterates the items of this control.
+ * ===Return value
+ * self
+ *
+*/
+DLL_LOCAL VALUE _each(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self,0,NULL,RUBY_METHOD_FUNC(_GetCount));
+	std::size_t count = _self->GetCount();
+	for(std::size_t i = 0; i < count; ++i)
+		rb_yield(wrap(_self->GetString(i)));
+	return self;
+}
+
+
+/*
+ * call-seq:
+ *   append(items) -> self
+ *
+ * adds new items to item container.
+ * ===Arguments
+ * * string items added to item container [String]
+ * ===Return value
+ * self
+ *
+*/
+DLL_LOCAL VALUE _Append(VALUE self,VALUE items)
+{
+	rb_check_frozen(self);
+	_self->Append(unwrap<wxArrayString>(items));
+	return self;
+}
+
+/*
+ * call-seq:
+ *   items(pos,items) -> self
+ *
+ * insert new items to item container at the given position.
+ * ===Arguments
+ * * pos where the item should be added.
+ * * string items added to item container [String]
+ * ===Return value
+ * * self
+ * === Exceptions
+ * [IndexError]
+ * * pos is greater than the count of items
+ *
+*/
+DLL_LOCAL VALUE _Insert(VALUE self,VALUE idx,VALUE items)
+{
+	rb_check_frozen(self);
+
+	if(!_self->IsSorted())
+	{
+		int cidx = NUM2INT(idx);
+		if(check_index(cidx,_self->GetCount()+1))
+			_self->Insert(unwrap<wxArrayString>(items),cidx);
+	}else
+		_self->Append(unwrap<wxArrayString>(items));
+
+	return self;
+}
+
+/*
+ * call-seq:
+ *   prepend(items) -> self
+ *
+ * prepends new items to item container.
+ * ===Arguments
+ * * string items prepend to item container [String]
+ * ===Return value
+ * self
+ *
+*/
+DLL_LOCAL VALUE _Prepend(VALUE self,VALUE items)
+{
+	rb_check_frozen(self);
+
+	if(!_self->IsSorted())
+		_self->Insert(unwrap<wxArrayString>(items),0);
+	else
+		_self->Append(unwrap<wxArrayString>(items));
+
+	return self;
+}
+
+
+DLL_LOCAL VALUE _Delete(VALUE self,VALUE idx)
+{
+	rb_check_frozen(self);
+
+	int cidx = NUM2INT(idx);
+	if(check_index(cidx,_self->GetCount()))
+		_self->Delete(cidx);
+	return self;
+}
+
+DLL_LOCAL VALUE _setItems(VALUE self,VALUE items)
+{
+	rb_check_frozen(self);
+	_self->Set(unwrap<wxArrayString>(items));
+	return items;
+}
+
+
+/*
+ * call-seq:
+ *   get_item_string(pos) -> String
+ *
+ * returns the String of the item at the given position.
+ * ===Arguments
+ * * pos of the item. Integer
+ * ===Return value
+ * String
+ * === Exceptions
+ * [IndexError]
+ * * pos is greater than the count of items
+ *
+*/
+DLL_LOCAL VALUE _getItemString(VALUE self,VALUE idx)
+{
+	int cidx = NUM2INT(idx);
+	if(check_index(cidx,_self->GetCount()))
+		return wrap(_self->GetString(cidx));
+	return Qnil;
+}
+
+/*
+ * call-seq:
+ *   set_item_string(pos,text) -> self
+ *
+ * sets the String of the item at the given position.
+ * ===Arguments
+ * * pos of the item. Integer
+ * * text of the item. String
+ * ===Return value
+ * self
+ * === Exceptions
+ * [IndexError]
+ * * pos is greater than the count of items
+ *
+*/
+DLL_LOCAL VALUE _setItemString(VALUE self,VALUE idx,VALUE val)
+{
+	rb_check_frozen(self);
+
+	int cidx = NUM2INT(idx);
+	if(check_index(cidx,_self->GetCount()))
+		_self->SetString(cidx,unwrap<wxString>(val));
+
+	return self;
+}
+
+
+}
+}
+#endif
+
+
+/* Document-method: clear
+ * call-seq:
+ *   clear -> self
+ *
+ * Removes all items from the control.
+ * ===Return value
+ * self
+*/
+
+/* Document-method: item_count
+ * call-seq:
+ *   item_count -> Integer
+ *
+ * Returns the number of items in the control.
+ * ===Return value
+ * Integer
+*/
+
+/* Document-method: sorted?
+ * call-seq:
+ *   sorted? -> true/false
+ *
+ * Return true if the control has specific style.
+ * ===Return value
+ * true/false
+*/
+/* Document-method: empty?
+ * call-seq:
+ *   empty? -> true/false
+ *
+ * Returns true if the control is empty or false if it has some items.
+ * ===Return value
+ * true/false
+*/
+
+/* Document-attr: selection
+ * Integer/nil returns the index of the current selected item, or nil if none is selected.
+ */
+/* Document-attr: string_selection
+ * String returns the string of the current selected item.
+ */
+/* Document-attr: items
+ * Array of the items in this control.
+ */
+
+
+DLL_LOCAL void Init_WXItemContainer(VALUE rb_mWX)
+{
+
+#if 0
+	rb_define_attr(rb_mWXItemContainer,"selection",1,1);
+	rb_define_attr(rb_mWXItemContainer,"string_selection",1,1);
+
+	rb_define_attr(rb_mWXItemContainer,"items",1,1);
+#endif
+
+#if wxUSE_CONTROLS
+	using namespace RubyWX::ItemContainer;
+
+	rb_mWXItemContainer = rb_define_module_under(rb_mWX,"ItemContainer");
+
+	rb_define_method(rb_mWXItemContainer,"clear",RUBY_METHOD_FUNC(_Clear),0);
+
+	rb_define_method(rb_mWXItemContainer,"each_item",RUBY_METHOD_FUNC(_each),0);
+
+	rb_define_method(rb_mWXItemContainer,"append",RUBY_METHOD_FUNC(_Append),1);
+	rb_define_alias(rb_mWXItemContainer,"<<","append");
+
+	rb_define_method(rb_mWXItemContainer,"insert",RUBY_METHOD_FUNC(_Insert),2);
+
+	rb_define_method(rb_mWXItemContainer,"prepend",RUBY_METHOD_FUNC(_Prepend),1);
+
+	rb_define_method(rb_mWXItemContainer,"delete_item",RUBY_METHOD_FUNC(_Delete),1);
+
+	rb_define_method(rb_mWXItemContainer,"get_item_string",RUBY_METHOD_FUNC(_getItemString),1);
+	rb_define_method(rb_mWXItemContainer,"set_item_string",RUBY_METHOD_FUNC(_setItemString),2);
+
+	rb_define_method(rb_mWXItemContainer,"item_count",RUBY_METHOD_FUNC(_GetCount),0);
+	rb_define_method(rb_mWXItemContainer,"sorted?",RUBY_METHOD_FUNC(_IsSorted),0);
+	rb_define_method(rb_mWXItemContainer,"empty?",RUBY_METHOD_FUNC(_IsEmpty),0);
+
+	rb_define_attr_method(rb_mWXItemContainer,"selection",_getSelection,_setSelection);
+	rb_define_attr_method(rb_mWXItemContainer,"string_selection",_getStringSelection,_setStringSelection);
+
+	rb_define_attr_method(rb_mWXItemContainer,"items",_GetStrings,_setItems);
+
+	//registerType<wxItemContainer>(rb_mWXItemContainer);
+#endif
+}
+