rwx 0.0.1.dev

data/ext/wxToolBarBase.hpp

@@ -0,0 +1,17 @@
+/*
+ * wxToolBarBase.hpp
+ *
+ *  Created on: 30.03.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXTOOLBARBASE_HPP_
+#define WXTOOLBARBASE_HPP_
+
+#include "wxControl.hpp"
+
+extern VALUE rb_cWXToolBarBase;
+
+void Init_WXToolBarBase(VALUE rb_mWX);
+
+#endif /* WXTOOLBARBASE_HPP_ */

data/ext/wxToolBarTool.cpp

@@ -0,0 +1,179 @@
+/*
+ * wxToolBarTool.cpp
+ *
+ *  Created on: 26.02.2012
+ *      Author: hanmac
+ */
+
+#include "wxBitmap.hpp"
+
+#include "wxToolBarBase.hpp"
+#include "wxToolBarTool.hpp"
+
+#if wxUSE_TOOLBAR
+
+#define _self unwrap<wxToolBarToolBase*>(self)
+
+VALUE rb_cWXToolBarTool;
+
+//need that for register
+struct wxToolBarTool;
+
+namespace RubyWX {
+namespace ToolBarTool {
+
+macro_attr(Label,wxString)
+macro_attr(ShortHelp,wxString)
+macro_attr(LongHelp,wxString)
+
+#if wxUSE_MENUS
+macro_attr(DropdownMenu,wxMenu*)
+#endif
+
+macro_attr_bool2(Enabled,Enable)
+macro_attr_bool2(Toggled,Toggle)
+
+singlereturn(GetToolBar)
+singlereturn(GetBitmap)
+singlereturn(GetNormalBitmap)
+singlereturn(GetDisabledBitmap)
+
+DLL_LOCAL VALUE _SetNormalBitmap(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+	_self->SetNormalBitmap(wrapBitmap(val,_self->GetId(),WRAP_BITMAP_RAISE,wxART_TOOLBAR));
+	return val;
+}
+
+DLL_LOCAL VALUE _SetDisabledBitmap(VALUE self,VALUE val)
+{
+	rb_check_frozen(self);
+	_self->SetDisabledBitmap(wrapBitmap(val,_self->GetId(),WRAP_BITMAP_NULL,wxART_TOOLBAR));
+	return val;
+}
+
+
+DLL_LOCAL VALUE _getControl(VALUE self)
+{
+	if(_self->IsControl())
+		return wrap(_self->GetControl());
+	return Qnil;
+}
+
+
+DLL_LOCAL VALUE _alloc(VALUE self)
+{
+
+	return wrap(new wxToolBarToolBase);
+}
+
+}
+}
+
+#endif
+
+
+/* Document-method: toolbar
+ * call-seq:
+ *   toolbar -> WX::ToolBar or nil
+ *
+ * returns the toolbar that has this ToolBarTool of nil.
+ * ===Return value
+ * WX::ToolBar or nil
+ */
+
+/* Document-method: bitmap
+ * call-seq:
+ *   bitmap -> WX::Bitmap
+ *
+ * returns the current bitmap of this tool bar item.
+ * ===Return value
+ * WX::Bitmap
+ */
+
+
+/* Document-attr: normal_bitmap
+ * returns the default WX::Bitmap
+ */
+/* Document-attr: disabled_bitmap
+ * returns the diabled WX::Bitmap
+ */
+
+/* Document-attr: label
+ * returns the label of the tool bar item. Type is String
+ */
+/* Document-attr: short_help
+ * returns the short help, used in status bar. Type is String
+ */
+/* Document-attr: long_help
+ * returns the long help, used in tool tip. Type is String
+ */
+
+/* Document-attr: dropdown_menu
+ * returns the dropdown menu WX::Menu
+ */
+
+
+/* Document-attr: enabled
+ * returns if the menu item is enabled. bool
+ */
+
+/* Document-attr: toggled
+ * returns if the menu item is toggled. bool
+ */
+
+
+DLL_LOCAL void Init_WXToolBarTool(VALUE rb_mWX)
+{
+#if 0
+	rb_cWXToolBarBase = rb_define_class_under(rb_mWX,"ToolBarBase",rb_cWXControl);
+
+	rb_define_attr(rb_cWXToolBarTool,"normal_bitmap",1,1);
+	rb_define_attr(rb_cWXToolBarTool,"disabled_bitmap",1,1);
+
+	rb_define_attr(rb_cWXToolBarTool,"label",1,1);
+	rb_define_attr(rb_cWXToolBarTool,"short_help",1,1);
+	rb_define_attr(rb_cWXToolBarTool,"long_help",1,1);
+
+	rb_define_attr(rb_cWXToolBarTool,"enabled",1,1);
+	rb_define_attr(rb_cWXToolBarTool,"toggled",1,1);
+
+	rb_define_attr(rb_cWXToolBarTool,"dropdown_menu",1,1);
+
+#endif
+
+#if wxUSE_TOOLBAR
+	using namespace RubyWX::ToolBarTool;
+	rb_cWXToolBarTool = rb_define_class_under(rb_cWXToolBarBase,"Tool",rb_cObject);
+
+	//should that really have alloc?
+	rb_define_alloc_func(rb_cWXToolBarTool,_alloc);
+
+	rb_undef_method(rb_cWXToolBarTool,"initialize_copy");
+	rb_undef_method(rb_cWXToolBarTool,"_load");
+	rb_undef_method(rb_cWXToolBarTool,"_dump");
+
+	rb_define_method(rb_cWXToolBarTool,"control",RUBY_METHOD_FUNC(_getControl),0);
+
+	rb_define_method(rb_cWXToolBarTool,"toolbar",RUBY_METHOD_FUNC(_GetToolBar),0);
+
+	rb_define_method(rb_cWXToolBarTool,"bitmap",RUBY_METHOD_FUNC(_GetBitmap),0);
+
+	rb_define_attr_method(rb_cWXToolBarTool,"normal_bitmap",_GetNormalBitmap,_SetNormalBitmap);
+	rb_define_attr_method(rb_cWXToolBarTool,"disabled_bitmap",_GetDisabledBitmap,_SetDisabledBitmap);
+
+	rb_define_attr_method(rb_cWXToolBarTool,"label",_getLabel,_setLabel);
+	rb_define_attr_method(rb_cWXToolBarTool,"short_help",_getShortHelp,_setShortHelp);
+	rb_define_attr_method(rb_cWXToolBarTool,"long_help",_getLongHelp,_setLongHelp);
+
+	rb_define_attr_method(rb_cWXToolBarTool,"enabled",_getEnabled,_setEnabled);
+	rb_define_attr_method(rb_cWXToolBarTool,"toggled",_getToggled,_setToggled);
+
+#if wxUSE_MENUS
+	rb_define_attr_method(rb_cWXToolBarTool,"dropdown_menu",_getDropdownMenu,_setDropdownMenu);
+#endif
+
+	registerInfo<wxToolBarToolBase>(rb_cWXToolBarTool);
+//	registerInfo<wxToolBarTool>(rb_cWXToolBarTool);
+#endif
+}

data/ext/wxToolBarTool.hpp

@@ -0,0 +1,16 @@
+/*
+ * wxToolBarTool.hpp
+ *
+ *  Created on: 26.02.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXTOOLBARTOOL_HPP_
+#define WXTOOLBARTOOL_HPP_
+
+#include "main.hpp"
+
+extern VALUE rb_cWXToolBarTool;
+void Init_WXToolBarTool(VALUE rb_mWX);
+
+#endif /* WXTOOLBARTOOL_HPP_ */

data/ext/wxToolBook.cpp

@@ -0,0 +1,96 @@
+/*
+ * wxToolBook.cpp
+ *
+ *  Created on: 14.04.2012
+ *      Author: hanmac
+ */
+
+#include "wxToolBook.hpp"
+#include "wxBookCtrl.hpp"
+
+VALUE rb_cWXToolbook;
+
+#if wxUSE_TOOLBOOK
+#define _self unwrap<wxToolbook*>(self)
+
+namespace RubyWX {
+namespace Toolbook {
+
+APP_PROTECT(wxToolbook)
+
+singlereturn(GetToolBar)
+singlefunc(Realize)
+
+/*
+ * 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
+ *
+*/
+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_WXToolBookCtrl(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_TOOLBOOK
+	using namespace RubyWX::Toolbook;
+	rb_cWXToolbook = rb_define_class_under(rb_mWX,"ToolBookCtrl",rb_cWXBookCtrlBase);
+	rb_define_alloc_func(rb_cWXToolbook,_alloc);
+
+	rb_define_method(rb_cWXToolbook,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_method(rb_cWXToolbook,"toolbar",RUBY_METHOD_FUNC(_GetToolBar),0);
+	rb_define_method(rb_cWXToolbook,"realize",RUBY_METHOD_FUNC(_Realize),0);
+
+	registerInfo<wxToolbook>(rb_cWXToolbook);
+
+	registerEventType<wxBookCtrlEvent>("toolbook_page_changed",wxEVT_TOOLBOOK_PAGE_CHANGED);
+	registerEventType<wxBookCtrlEvent>("toolbook_page_changing",wxEVT_TOOLBOOK_PAGE_CHANGING);
+#endif
+
+}
+
+
+
+
+
+

data/ext/wxToolBook.hpp

@@ -0,0 +1,23 @@
+/*
+ * wxToolBook.hpp
+ *
+ *  Created on: 14.04.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXTOOLBOOK_HPP_
+#define WXTOOLBOOK_HPP_
+
+
+#include "wxEvtHandler.hpp"
+
+extern VALUE rb_cWXToolbook;
+
+void Init_WXToolBookCtrl(VALUE rb_mWX);
+
+#if wxUSE_TOOLBOOK
+#include <wx/toolbook.h>
+#endif
+
+
+#endif /* WXTOOLBOOK_HPP_ */

data/ext/wxToplevel.cpp

@@ -0,0 +1,125 @@
+/*
+ * wxToplevel.cpp
+ *
+ *  Created on: 05.02.2012
+ *      Author: hanmac
+ */
+
+#include "wxWindow.hpp"
+#include "wxBitmap.hpp"
+
+VALUE rb_cWXTopLevel;
+
+#define _self unwrap<wxTopLevelWindow*>(self)
+
+namespace RubyWX {
+namespace TopLevel {
+
+macro_attr(Title,wxString)
+macro_attr(Icon,wxIcon)
+macro_attr(DefaultItem,wxWindow*)
+macro_attr(TmpDefaultItem,wxWindow*)
+
+void set_style_flags(VALUE hash,int& flags)
+{
+
+	set_hash_flag_option(hash,"stay_on_top",wxSTAY_ON_TOP,flags);
+	set_hash_flag_option(hash,"iconize",wxICONIZE,flags);
+	set_hash_flag_option(hash,"minimize",wxMINIMIZE,flags);
+	set_hash_flag_option(hash,"maximize",wxMAXIMIZE,flags);
+	set_hash_flag_option(hash,"close_box",wxCLOSE_BOX,flags);
+	set_hash_flag_option(hash,"system_menu",wxSYSTEM_MENU,flags);
+	set_hash_flag_option(hash,"minimize_box",wxMINIMIZE_BOX,flags);
+	set_hash_flag_option(hash,"maximize_box",wxMAXIMIZE_BOX,flags);
+	set_hash_flag_option(hash,"tiny_caption",wxTINY_CAPTION,flags);
+	set_hash_flag_option(hash,"resize_border",wxRESIZE_BORDER,flags);
+
+}
+
+//APP_PROTECT(wxTopLevelWindow)
+
+/*
+ * call-seq:
+ *   TopLevel.new(parent, name, [options])
+ *   TopLevel.new(parent, [options])
+ *
+ * creates a new Control 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:
+ *   * title String Shown in the TitleBar of framed Window
+ *   * icon WX::Bitmap Shown in the TitleBar of framed Window
+ *
+*/
+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(hash,rb_cHash))
+	{
+		VALUE temp;
+		set_option(title,Title,wxString)
+		set_option(icon,Icon,wxIcon)
+	}
+	rb_call_super(argc,argv);
+	return self;
+}
+
+
+}
+}
+
+
+/* Document-attr: title
+ * returns the title of the TopLevel window. Type is String
+ */
+
+/* Document-attr: icon
+ * returns the icon of the TopLevel window. Type is WX::Bitmap
+ */
+
+
+DLL_LOCAL void Init_WXTopLevel(VALUE rb_mWX)
+{
+#if 0
+	rb_mWX = rb_define_module("WX");
+	rb_cWXWindow = rb_define_class_under(rb_mWX,"Window",rb_cObject);
+
+	rb_define_attr(rb_cWXTopLevel, "title",1,1);
+	rb_define_attr(rb_cWXTopLevel, "icon",1,1);
+
+	rb_define_attr(rb_cWXTopLevel, "default_item",1,1);
+	rb_define_attr(rb_cWXTopLevel, "tmp_default_item",1,1);
+
+#endif
+
+	using namespace RubyWX::TopLevel;
+	rb_cWXTopLevel = rb_define_class_under(rb_mWX,"TopLevel",rb_cWXWindow);
+	rb_undef_alloc_func(rb_cWXTopLevel);
+
+	rb_define_method(rb_cWXTopLevel,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_attr_method(rb_cWXTopLevel, "title",_getTitle,_setTitle);
+	rb_define_attr_method(rb_cWXTopLevel, "icon",_getIcon,_setIcon);
+
+	rb_define_attr_method(rb_cWXTopLevel, "default_item",_getDefaultItem,_setDefaultItem);
+	rb_define_attr_method(rb_cWXTopLevel, "tmp_default_item",_getTmpDefaultItem,_setTmpDefaultItem);
+
+
+	rb_define_const(rb_cWXTopLevel,"STAY_ON_TOP",INT2NUM(wxSTAY_ON_TOP));
+	rb_define_const(rb_cWXTopLevel,"ICONIZE",INT2NUM(wxICONIZE));
+	rb_define_const(rb_cWXTopLevel,"MINIMIZE",INT2NUM(wxMINIMIZE));
+	rb_define_const(rb_cWXTopLevel,"MAXIMIZE",INT2NUM(wxMAXIMIZE));
+	rb_define_const(rb_cWXTopLevel,"CLOSE_BOX",INT2NUM(wxCLOSE_BOX));
+
+	rb_define_const(rb_cWXTopLevel,"SYSTEM_MENU",INT2NUM(wxSYSTEM_MENU));
+	rb_define_const(rb_cWXTopLevel,"MINIMIZE_BOX",INT2NUM(wxMINIMIZE_BOX));
+	rb_define_const(rb_cWXTopLevel,"MAXIMIZE_BOX",INT2NUM(wxMAXIMIZE_BOX));
+
+	rb_define_const(rb_cWXTopLevel,"TINY_CAPTION",INT2NUM(wxTINY_CAPTION));
+	rb_define_const(rb_cWXTopLevel,"RESIZE_BORDER",INT2NUM(wxRESIZE_BORDER));
+
+	registerInfo<wxTopLevelWindow>(rb_cWXTopLevel);
+}