rwx 0.0.1.dev

data/ext/wxMenu.hpp

@@ -0,0 +1,17 @@
+/*
+ * wxMenu.hpp
+ *
+ *  Created on: 17.02.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXMENU_HPP_
+#define WXMENU_HPP_
+
+
+#include "main.hpp"
+
+extern VALUE rb_cWXMenu;
+DLL_LOCAL void Init_WXMenu(VALUE rb_mWX);
+
+#endif /* WXMENU_HPP_ */

data/ext/wxMenuBar.cpp

@@ -0,0 +1,180 @@
+/*
+ * wxMenuBar.cpp
+ *
+ *  Created on: 24.02.2012
+ *      Author: hanmac
+ */
+
+#include "wxApp.hpp"
+
+#include "wxMenu.hpp"
+#include "wxEvtHandler.hpp"
+
+VALUE rb_cWXMenuBar;
+
+#if wxUSE_MENUS
+#define _self unwrap<wxMenuBar*>(self)
+
+namespace RubyWX {
+namespace MenuBar {
+
+APP_PROTECT(wxMenuBar)
+
+DLL_LOCAL VALUE _initialize(int argc,VALUE *argv,VALUE self)
+{
+	rb_call_super(argc,argv);
+	return self;
+}
+
+DLL_LOCAL VALUE _each_size(VALUE self)
+{
+	return UINT2NUM(_self->GetMenuCount());
+}
+
+
+DLL_LOCAL VALUE _each(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self,0,NULL,RUBY_METHOD_FUNC(_each_size));
+	std::size_t count = _self->GetMenuCount();
+	for(std::size_t i = 0;i < count;++i)
+		rb_yield(wrap(_self->GetMenu(i)));
+	return self;
+}
+
+
+wxMenu* add_base(VALUE menu,wxString &name)
+{
+	wxMenu *m = NULL;
+	if(!rb_obj_is_kind_of(menu,rb_cWXMenu))
+	{
+		m = new wxMenu;
+		if(rb_block_given_p())
+			rb_yield(wrap(m));
+
+		name = unwrap<wxString>(menu);
+
+		if(SYMBOL_P(menu))
+		{
+			wxWindowID id(unwrapID(menu));
+			if(wxIsStockID(id))
+			{
+				name = wxGetStockLabel(id);
+			}
+		}
+
+	} else {
+		m = unwrap<wxMenu*>(menu);
+		name = m->GetTitle();
+	}
+
+	if(name.IsEmpty())
+		rb_raise(rb_eArgError,"Menu must have a title.");
+
+	return m;
+}
+
+DLL_LOCAL VALUE _appendSelf(VALUE self,VALUE menu)
+{
+	wxString name(wxEmptyString);
+
+	_self->Append(add_base(menu,name),name);
+	return self;
+}
+
+
+/*
+ * call-seq:
+ *   append(menu) -> true/false
+ *   append(title) {|menu| } -> true/false
+ * ===Arguments
+ * * menu WX::Menu
+ * * title String
+ *
+ * ===Return value
+ * true/false
+ */
+DLL_LOCAL VALUE _append(VALUE self,VALUE menu)
+{
+	wxString name(wxEmptyString);
+
+	return wrap(_self->Append(add_base(menu,name),name));
+}
+
+
+/*
+ * call-seq:
+ *   insert(idx, menu) -> true/false
+ *   insert(idx, title) {|menu| } -> true/false
+ * ===Arguments
+ * * idx Integer
+ * * menu WX::Menu
+ * * title String
+ *
+ * ===Return value
+ * true/false
+ */
+DLL_LOCAL VALUE _insert(VALUE self,VALUE idx,VALUE menu)
+{
+	wxString name(wxEmptyString);
+	int cidx = NUM2INT(idx);
+
+	if(check_index(cidx,_self->GetMenuCount()+1))
+		return wrap(_self->Insert(cidx,add_base(menu,name),name));
+
+	return Qnil;
+}
+
+
+/*
+ * call-seq:
+ *   prepend(menu) -> true/false
+ *   prepend(title) {|menu| } -> true/false
+ * ===Arguments
+ * * menu WX::Menu
+ * * title String
+ *
+ * ===Return value
+ * true/false
+ */
+DLL_LOCAL VALUE _prepend(VALUE self,VALUE menu)
+{
+	wxString name(wxEmptyString);
+
+	return wrap(_self->Insert(0,add_base(menu,name),name));
+}
+singlereturn(GetFrame);
+
+}
+}
+
+#endif
+
+DLL_LOCAL void Init_WXMenuBar(VALUE rb_mWX)
+{
+#if 0
+	rb_mWX = rb_define_module("WX");
+	rb_cWXWindow = rb_define_class_under(rb_mWX,"Window",rb_cObject);
+
+#endif
+#if wxUSE_MENUS
+	using namespace RubyWX::MenuBar;
+	rb_cWXMenuBar = rb_define_class_under(rb_mWX,"MenuBar",rb_cWXWindow);
+	rb_define_alloc_func(rb_cWXMenuBar,_alloc);
+
+	rb_define_method(rb_cWXMenuBar,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_method(rb_cWXMenuBar,"each_menu",RUBY_METHOD_FUNC(_each),0);
+
+	rb_define_method(rb_cWXMenuBar,"<<",RUBY_METHOD_FUNC(_appendSelf),1);
+
+	rb_define_method(rb_cWXMenuBar,"append",RUBY_METHOD_FUNC(_append),1);
+	rb_define_method(rb_cWXMenuBar,"insert",RUBY_METHOD_FUNC(_insert),2);
+	rb_define_method(rb_cWXMenuBar,"prepend",RUBY_METHOD_FUNC(_prepend),1);
+
+	rb_define_method(rb_cWXMenuBar,"frame",RUBY_METHOD_FUNC(_GetFrame),0);
+
+	rb_define_const(rb_cWXMenuBar,"DOCKABLE",INT2NUM(wxMB_DOCKABLE));
+
+	registerInfo<wxMenuBar>(rb_cWXMenuBar);
+#endif
+}

data/ext/wxMenuBar.hpp

@@ -0,0 +1,17 @@
+/*
+ * wxMenuBar.hpp
+ *
+ *  Created on: 24.02.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXMENUBAR_HPP_
+#define WXMENUBAR_HPP_
+
+
+#include "wxWindow.hpp"
+
+extern VALUE rb_cWXMenuBar;
+DLL_LOCAL void Init_WXMenuBar(VALUE rb_mWX);
+
+#endif /* WXMENUBAR_HPP_ */

data/ext/wxMenuItem.cpp

@@ -0,0 +1,174 @@
+/*
+ * wxMenuItem.cpp
+ *
+ *  Created on: 18.02.2012
+ *      Author: hanmac
+ */
+
+#include "wxWindow.hpp"
+#include "wxApp.hpp"
+#include "wxMenu.hpp"
+#include "wxMenuItem.hpp"
+#include "wxBitmap.hpp"
+
+
+
+VALUE rb_cWXMenuItem;
+
+#if wxUSE_MENUS
+
+#define _self unwrap<wxMenuItem*>(self)
+
+namespace RubyWX {
+namespace MenuItem {
+
+APP_PROTECT(wxMenuItem)
+
+macro_attr(Menu,wxMenu*)
+macro_attr(ItemLabel,wxString)
+macro_attr_with_func(Id,wrapID,unwrapID)
+macro_attr_enum(Kind,wxItemKind)
+macro_attr(SubMenu,wxMenu*)
+
+macro_attr(Help,wxString)
+
+singlereturn(GetBitmap)
+
+DLL_LOCAL VALUE _SetBitmap(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+	_self->SetBitmap(wrapBitmap(val,_self->GetId(),WRAP_BITMAP_RAISE,wxART_MENU));
+	return val;
+}
+
+/*
+*/
+DLL_LOCAL VALUE _initialize_copy(VALUE self,VALUE other)
+{
+	_setItemLabel(self,_getItemLabel(other));
+	_setId(self,_getId(other));
+	_setKind(self,_getKind(other));
+	_setSubMenu(self,_getSubMenu(other));
+	_setHelp(self,_getHelp(other));
+	_SetBitmap(self,_GetBitmap(other));
+	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 result = rb_ary_new();
+
+	rb_ary_push(result,_getItemLabel(self));
+	rb_ary_push(result,_getId(self));
+	rb_ary_push(result,_getKind(self));
+//	rb_ary_push(result,_getSubMenu(self));
+	rb_ary_push(result,_getHelp(self));
+#if wxUSE_IMAGE
+	rb_ary_push(result,_GetBitmap(self));
+#endif
+	return result;
+}
+
+/*
+ * call-seq:
+ *   marshal_load(array) -> nil
+ *
+ * Provides marshalling support for use by the Marshal library.
+ *
+ *
+ */
+DLL_LOCAL VALUE _marshal_load(VALUE self,VALUE data)
+{
+	_setItemLabel(self,RARRAY_AREF(data,0));
+	_setId(self,RARRAY_AREF(data,1));
+	_setKind(self,RARRAY_AREF(data,2));
+
+	_setHelp(self,RARRAY_AREF(data,3));
+#if wxUSE_IMAGE
+	_SetBitmap(self,RARRAY_AREF(data,4));
+#endif
+	return self;
+}
+
+
+}
+}
+
+#endif
+
+/*
+ * Document-class: WX::Menu::Item
+ *
+ * This class represents an Item inside a WX::Menu
+*/
+
+/* Document-attr: menu
+ * returns the parent menu, this attribute are not copied with inititalize_copy or stored with Marshal
+ */
+/* Document-attr: label
+ * returns the label of the menu item. Type is String
+ */
+/* Document-attr: id
+ * returns the Id of the menu item. Type can be Symbol,if pre- or user defined, or Integer if auto generated.
+ */
+/* Document-attr: sub_menu
+ * returns the sub_menu, currently can be copied with inititalize_copy but not stored with Marshal
+ */
+/* Document-attr: help
+ * returns the help string of the menu item. Type is String
+ */
+/* Document-attr: bitmap
+ * returns the Bitmap, currently can be copied with inititalize_copy but only stored with Marshal when wxImage is available
+ */
+
+DLL_LOCAL void Init_WXMenuItem(VALUE rb_mWX)
+{
+#if 0
+	rb_cWXMenu = rb_define_class_under(rb_mWX,"Menu",rb_cObject);
+
+	rb_define_attr(rb_cWXMenuItem,"menu",1,1);
+	rb_define_attr(rb_cWXMenuItem,"label",1,1);
+	rb_define_attr(rb_cWXMenuItem,"id",1,1);
+
+	rb_define_attr(rb_cWXMenuItem,"sub_menu",1,1);
+
+	rb_define_attr(rb_cWXMenuItem,"help",1,1);
+
+	rb_define_attr(rb_cWXMenuItem,"bitmap",1,1);
+
+#endif
+
+#if wxUSE_MENUS
+	using namespace RubyWX::MenuItem;
+	//
+	rb_cWXMenuItem = rb_define_class_under(rb_cWXMenu,"Item",rb_cObject);
+	rb_define_alloc_func(rb_cWXMenuItem,_alloc);
+
+	rb_define_private_method(rb_cWXMenuItem,"initialize_copy",RUBY_METHOD_FUNC(_initialize_copy),0);
+
+	rb_define_attr_method(rb_cWXMenuItem,"menu",_getMenu,_setMenu);
+	rb_define_attr_method(rb_cWXMenuItem,"label",_getItemLabel,_setItemLabel);
+	rb_define_attr_method(rb_cWXMenuItem,"id",_getId,_setId);
+
+	rb_define_attr_method(rb_cWXMenuItem,"sub_menu",_getSubMenu,_setSubMenu);
+
+	rb_define_attr_method(rb_cWXMenuItem,"help",_getHelp,_setHelp);
+
+	rb_define_attr_method(rb_cWXMenuItem,"bitmap",_GetBitmap,_SetBitmap);
+
+	rb_define_method(rb_cWXMenuItem,"marshal_dump",RUBY_METHOD_FUNC(_marshal_dump),0);
+	rb_define_method(rb_cWXMenuItem,"marshal_load",RUBY_METHOD_FUNC(_marshal_load),1);
+
+
+	registerInfo<wxMenuItem>(rb_cWXMenuItem);
+
+#endif
+}

data/ext/wxMenuItem.hpp

@@ -0,0 +1,17 @@
+/*
+ * wxMenuItem.hpp
+ *
+ *  Created on: 18.02.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXMENUITEM_HPP_
+#define WXMENUITEM_HPP_
+
+
+#include "main.hpp"
+
+extern VALUE rb_cWXMenuItem;
+DLL_LOCAL void Init_WXMenuItem(VALUE rb_mWX);
+
+#endif /* WXMENUITEM_HPP_ */

data/ext/wxMessageDialog.cpp

@@ -0,0 +1,91 @@
+/*
+ * wxMessageDialog.cpp
+ *
+ *  Created on: 25.11.2012
+ *      Author: hanmac
+ */
+
+
+#include "wxMessageDialog.hpp"
+
+VALUE rb_cWXMessageDialog;
+
+#if wxUSE_MSGDLG
+#define _self unwrap<wxMessageDialog*>(self)
+
+namespace RubyWX {
+namespace MessageDialog {
+
+#ifdef HAVE_WXMESSAGEDIALOG
+APP_PROTECT(wxMessageDialog)
+#else
+APP_PROTECT_NULL
+#endif
+
+DLL_LOCAL VALUE _initialize(int argc,VALUE *argv,VALUE self)
+{
+	VALUE parent,name,hash;
+	rb_scan_args(argc, argv, "11:",&parent,&name,&hash);
+
+	wxString message;
+	wxString caption(wxMessageBoxCaptionStr);
+	int style(wxOK|wxCENTRE);
+
+#ifdef HAVE_WXMESSAGEDIALOG
+	if(!_created && rb_obj_is_kind_of(name,rb_cString)) {
+
+		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,"style",style);
+		}
+
+		_self->Create(
+			unwrap<wxWindow*>(parent),message,caption,style
+		);
+
+	}
+#else
+	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,"style",style);
+	}
+
+	RTYPEDDATA_DATA(self) = new wxMessageDialog(
+		unwrap<wxWindow*>(parent),message,caption,style
+	);
+
+#endif
+
+	rb_call_super(argc,argv);
+	return self;
+}
+
+
+}
+}
+#endif
+DLL_LOCAL void Init_WXMessageDialog(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_cWXMessageDialogBase = rb_define_class_under(rb_mWX,"MessageDialogBase",rb_cWXDialog);
+#endif
+
+#if wxUSE_MSGDLG
+	using namespace RubyWX::MessageDialog;
+	rb_cWXMessageDialog = rb_define_class_under(rb_mWX,"MessageDialog",rb_cWXMessageDialogBase);
+	rb_define_alloc_func(rb_cWXMessageDialog,_alloc);
+
+	rb_define_method(rb_cWXMessageDialog,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	registerInfo<wxMessageDialog>(rb_cWXMessageDialog);
+#endif
+
+}