rwx 0.0.1.dev

data/ext/wxTextAttr.hpp

@@ -0,0 +1,28 @@
+/*
+ * wxTextAttr.hpp
+ *
+ *  Created on: 28.04.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXTEXTATTR_HPP_
+#define WXTEXTATTR_HPP_
+
+#include "wxControl.hpp"
+
+extern VALUE rb_cWXTextAttr;
+
+void Init_WXTextAttr(VALUE rb_mWX);
+
+#if wxUSE_TEXTCTRL
+#include <wx/textctrl.h>
+
+template <>
+VALUE wrap< wxTextAttr >(wxTextAttr *color );
+
+template <>
+wxTextAttr unwrap< wxTextAttr >(const VALUE &vcolor);
+
+#endif
+
+#endif /* WXTEXTATTR_HPP_ */

data/ext/wxTextCtrl.cpp

@@ -0,0 +1,177 @@
+/*
+ * wxTextCtrl.cpp
+ *
+ *  Created on: 27.04.2012
+ *      Author: hanmac
+ */
+
+#include "wxTextCtrl.hpp"
+
+#include "wxTextArea.hpp"
+#include "wxTextEntry.hpp"
+
+VALUE rb_cWXTextCtrl;
+
+#if wxUSE_TEXTCTRL
+#define _self unwrap<wxTextCtrl*>(self)
+
+namespace RubyWX {
+namespace TextCtrl {
+
+void set_style_flags(VALUE hash,int& style)
+{
+	set_hash_flag_option(hash,"readonly",wxTE_READONLY,style);
+	set_hash_flag_option(hash,"multiline",wxTE_MULTILINE,style);
+	set_hash_flag_option(hash,"password",wxTE_PASSWORD,style);
+	set_hash_flag_option(hash,"process_tab",wxTE_PROCESS_TAB,style);
+	set_hash_flag_option(hash,"process_enter",wxTE_PROCESS_ENTER,style);
+
+	if(((style & wxTE_MULTILINE) != 0) && ((style & (wxTE_PASSWORD|wxTE_PROCESS_ENTER)) != 0) )
+	{
+		rb_raise(rb_eArgError,"password style and process enter style are for singleline only");
+	}
+
+}
+
+
+macro_attr(Value,wxString)
+
+singlereturn(IsSingleLine)
+singlereturn(IsMultiLine)
+
+APP_PROTECT(wxTextCtrl)
+
+
+/*
+ * call-seq:
+ *   TextCtrl.new(parent, name, [options])
+ *   TextCtrl.new(parent, [options])
+ *
+ * creates a new TextCtrl 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 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))
+	{
+		wxWindowID id(wxID_ANY);
+		wxString value(wxEmptyString);
+		int style(0);
+
+		if(rb_obj_is_kind_of(hash,rb_cHash))
+		{
+			set_hash_option(hash,"id",id,unwrapID);
+			set_hash_option(hash,"value",value);
+			set_hash_option(hash,"style",style);
+
+			set_style_flags(hash,style);
+		}
+
+		_self->Create(unwrap<wxWindow*>(parent),id,value,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(value,Value,wxString)
+	}
+
+	return self;
+}
+
+}
+}
+#endif
+
+
+/* Document-attr: value
+ * the value of the TextCtrl. String
+ */
+
+/* Document-method: single_line?
+ * call-seq:
+ *   single_line? -> true/false
+ *
+ * Returns true if this is a single line edit control and false otherwise.
+ * ===Return value
+ * true/false
+*/
+/* Document-method: multi_line?
+ * call-seq:
+ *   multi_line? -> true/false
+ *
+ * Returns true if this is a multi line edit control and false otherwise.
+ * ===Return value
+ * true/false
+*/
+
+/* Document-const: READONLY
+ *   The text will not be user-editable.
+ */
+/* Document-const: MULTILINE
+ *   The text control allows multiple lines. If this style is not specified, line break characters should not be used in the controls value.
+ */
+/* Document-const: PROCESS_TAB
+ *   The control will receive :char events for TAB pressed - normally, TAB is used for passing to the next control in a dialog instead. For the control created with this style, you can still use Ctrl-Enter to pass to the next control from the keyboard.
+ */
+/* Document-const: PROCESS_ENTER
+ *  The control will generate the event :text_enter (otherwise pressing Enter key is either processed internally by the control or used for navigation between dialog controls).
+ */
+/* Document-const: PASSWORD
+ *   The text will be echoed as asterisks.
+ */
+DLL_LOCAL void Init_WXTextCtrl(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_mWXTextArea = rb_define_module_under(rb_mWX,"TextArea");
+	rb_mWXTextEntry = rb_define_module_under(rb_mWX,"TextEntry");
+
+	rb_define_attr(rb_cWXTextCtrl,"value",1,1);
+#endif
+
+#if wxUSE_TEXTCTRL
+	using namespace RubyWX::TextCtrl;
+	rb_cWXTextCtrl = rb_define_class_under(rb_mWX,"TextCtrl",rb_cWXControl);
+	rb_define_alloc_func(rb_cWXTextCtrl,_alloc);
+
+	rb_include_module(rb_cWXTextCtrl,rb_mWXTextArea);
+	rb_include_module(rb_cWXTextCtrl,rb_mWXTextEntry);
+
+	rb_define_method(rb_cWXTextCtrl,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_method(rb_cWXTextCtrl,"single_line?",RUBY_METHOD_FUNC(_IsSingleLine),0);
+	rb_define_method(rb_cWXTextCtrl,"multi_line?",RUBY_METHOD_FUNC(_IsMultiLine),0);
+
+	rb_define_attr_method(rb_cWXTextCtrl,"value",_getValue,_setValue);
+
+	rb_define_const(rb_cWXTextCtrl,"READONLY",INT2NUM(wxTE_READONLY));
+	rb_define_const(rb_cWXTextCtrl,"MULTILINE",INT2NUM(wxTE_MULTILINE));
+	rb_define_const(rb_cWXTextCtrl,"PROCESS_TAB",INT2NUM(wxTE_PROCESS_TAB));
+	rb_define_const(rb_cWXTextCtrl,"PROCESS_ENTER",INT2NUM(wxTE_PROCESS_ENTER));
+	rb_define_const(rb_cWXTextCtrl,"PASSWORD",INT2NUM(wxTE_PASSWORD));
+
+	registerEventType("text",wxEVT_TEXT,rb_cWXCommandEvent);
+	registerEventType("text_enter",wxEVT_TEXT_ENTER,rb_cWXCommandEvent);
+	registerEventType("text_url",wxEVT_TEXT_URL,rb_cWXCommandEvent);
+	registerEventType("text_maxlen",wxEVT_TEXT_MAXLEN,rb_cWXCommandEvent);
+
+	registerInfo<wxTextCtrl>(rb_cWXTextCtrl);
+#endif
+
+}

data/ext/wxTextCtrl.hpp

@@ -0,0 +1,30 @@
+/*
+ * wxtextCtrl.hpp
+ *
+ *  Created on: 28.04.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXTEXTCTRL_HPP_
+#define WXTEXTCTRL_HPP_
+
+#include "wxControl.hpp"
+
+extern VALUE rb_cWXTextCtrl;
+
+void Init_WXTextCtrl(VALUE rb_mWX);
+
+#if wxUSE_TEXTCTRL
+#include <wx/textctrl.h>
+#endif
+
+namespace RubyWX {
+namespace TextCtrl {
+
+void set_style_flags(VALUE hash,int& flags);
+
+}
+}
+
+
+#endif /* WXTEXTCTRL_HPP_ */

data/ext/wxTextEntry.cpp

@@ -0,0 +1,248 @@
+/*
+ * wxTextEntry.cpp
+ *
+ *  Created on: 30.12.2013
+ *      Author: hanmac
+ */
+
+#include "wxTextEntry.hpp"
+#include "wxTextCtrl.hpp"
+#include "wxRichTextCtrl.hpp"
+#include "wxSearchCtrl.hpp"
+#include "wxBitmapComboBox.hpp"
+#include "wxComboBox.hpp"
+#include "wxSTC.hpp"
+#include "wxPoint.hpp"
+
+VALUE rb_mWXTextEntry;
+
+template <>
+wxTextEntryBase* unwrap< wxTextEntryBase* >(const VALUE &obj)
+{
+#if	wxUSE_TEXTCTRL
+	if(rb_obj_is_kind_of(obj,rb_cWXTextCtrl))
+		return unwrap<wxTextCtrl*>(obj);
+#endif
+#if	wxUSE_RICHTEXT
+	if(rb_obj_is_kind_of(obj,rb_cWXRichTextCtrl))
+		return unwrap<wxRichTextCtrl*>(obj);
+#endif
+#if	wxUSE_SEARCHCTRL
+	if(rb_obj_is_kind_of(obj,rb_cWXSearchCtrl))
+		return unwrap<wxSearchCtrl*>(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
+#if wxUSE_STC
+	if(rb_obj_is_kind_of(obj,rb_cWXSTC))
+		return unwrap<wxStyledTextCtrl*>(obj);
+#endif
+	rb_raise(rb_eTypeError,"Unknown wxTextEntryBase: %s",rb_obj_classname(obj));
+	return NULL;
+}
+
+
+#define _self unwrap<wxTextEntryBase*>(self)
+
+namespace RubyWX {
+namespace TextEntry {
+
+
+singlefunc(Copy)
+singlefunc(Cut)
+singlefunc(Paste)
+
+singlereturn(CanCopy)
+singlereturn(CanCut)
+singlereturn(CanPaste)
+
+singlefunc(Undo)
+singlefunc(Redo)
+
+singlereturn(CanUndo)
+singlereturn(CanRedo)
+
+singlefunc(SelectAll)
+singlefunc(SelectNone)
+singlereturn(HasSelection)
+
+macro_attr(Hint,wxString)
+
+macro_attr_bool(Editable)
+
+macro_attr(Margins,wxPoint)
+
+
+/*
+ * call-seq:
+ *   initialize(parent, [options])
+ *
+ *
+ * ===Arguments
+ * * parent of this window or nil
+ *
+ * *options: Hash with possible options to set:
+ *   * value String
+ *
+*/
+DLL_LOCAL VALUE _initialize(int argc,VALUE *argv,VALUE self)
+{
+	VALUE parent,name,hash;
+	rb_scan_args(argc, argv, "11:",&parent,&name,&hash);
+
+	rb_call_super(argc,argv);
+
+	if(rb_obj_is_kind_of(hash,rb_cHash))
+	{
+		VALUE temp;
+		set_option(hint,Hint,wxString)
+		set_option(editable,Editable,bool)
+		set_option(margins,Margins,wxPoint)
+	}
+
+	return self;
+}
+
+}
+}
+
+
+/* Document-method: copy
+ * call-seq:
+ *   copy -> self
+ *
+ * copy into clipboard.
+ * ===Return value
+ * self
+ */
+
+/* Document-method: cut
+ * call-seq:
+ *   cut -> self
+ *
+ * cut into clipboard.
+ * ===Return value
+ * self
+ */
+
+/* Document-method: paste
+ * call-seq:
+ *   paste -> self
+ *
+ * paste from clipboard.
+ * ===Return value
+ * self
+ */
+
+/* Document-method: undo
+ * call-seq:
+ *   undo -> self
+ *
+ * undo last action
+ * ===Return value
+ * self
+ */
+
+/* Document-method: redo
+ * call-seq:
+ *   redo -> self
+ *
+ * redo last undo'd action.
+ * ===Return value
+ * self
+ */
+
+/* Document-method: can_copy?
+ * call-seq:
+ *   can_copy? -> true/false
+ *
+ *  returns true if copy can be called.
+ * ===Return value
+ * true/false
+ */
+
+/* Document-method: can_cut?
+ * call-seq:
+ *   can_cut? -> true/false
+ *
+ *  returns true if cut can be called.
+ * ===Return value
+ * true/false
+ */
+
+/* Document-method: can_paste?
+ * call-seq:
+ *   can_paste? -> true/false
+ *
+ *  returns true if paste can be called.
+ * ===Return value
+ * true/false
+ */
+
+/* Document-method: can_undo?
+ * call-seq:
+ *   can_undo? -> true/false
+ *
+ *  returns true if copy can be called.
+ * ===Return value
+ * true/false
+ */
+
+/* Document-method: can_redo?
+ * call-seq:
+ *   can_redo? -> true/false
+ *
+ *  returns true if redo can be called.
+ * ===Return value
+ * true/false
+ */
+
+/* Document-attr: hint
+ * the hint of the TextEntry. String
+ */
+/* Document-attr: value
+ * the editable value of the TextEntry. bool
+ */
+/* Document-attr: margins
+ * the margins of the TextEntry. WX::Point
+ */
+DLL_LOCAL void Init_WXTextEntry(VALUE rb_mWX)
+{
+#if 0
+	rb_define_attr(rb_mWXTextEntry,"hint",1,1);
+	rb_define_attr(rb_mWXTextEntry,"editable",1,1);
+	rb_define_attr(rb_mWXTextEntry,"margins",1,1);
+#endif
+
+	using namespace RubyWX::TextEntry;
+	rb_mWXTextEntry = rb_define_module_under(rb_mWX,"TextEntry");
+
+	rb_define_method(rb_mWXTextEntry,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_method(rb_mWXTextEntry,"cut",RUBY_METHOD_FUNC(_Cut),0);
+	rb_define_method(rb_mWXTextEntry,"copy",RUBY_METHOD_FUNC(_Copy),0);
+	rb_define_method(rb_mWXTextEntry,"paste",RUBY_METHOD_FUNC(_Paste),0);
+
+	rb_define_method(rb_mWXTextEntry,"can_cut?",RUBY_METHOD_FUNC(_CanCut),0);
+	rb_define_method(rb_mWXTextEntry,"can_copy?",RUBY_METHOD_FUNC(_CanCopy),0);
+	rb_define_method(rb_mWXTextEntry,"can_paste?",RUBY_METHOD_FUNC(_CanPaste),0);
+
+	rb_define_method(rb_mWXTextEntry,"undo",RUBY_METHOD_FUNC(_Undo),0);
+	rb_define_method(rb_mWXTextEntry,"redo",RUBY_METHOD_FUNC(_Redo),0);
+
+	rb_define_method(rb_mWXTextEntry,"can_undo?",RUBY_METHOD_FUNC(_CanUndo),0);
+	rb_define_method(rb_mWXTextEntry,"can_redo?",RUBY_METHOD_FUNC(_CanRedo),0);
+
+	rb_define_attr_method(rb_mWXTextEntry,"hint",_getHint,_setHint);
+	rb_define_attr_method(rb_mWXTextEntry,"editable",_getEditable,_setEditable);
+	rb_define_attr_method(rb_mWXTextEntry,"margins",_getMargins,_setMargins);
+}
+
+
+