rwx 0.0.1.dev

data/ext/wxGauge.hpp

@@ -0,0 +1,17 @@
+/*
+ * wxGauge.hpp
+ *
+ *  Created on: 27.02.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXGAUGE_HPP_
+#define WXGAUGE_HPP_
+
+#include "wxControl.hpp"
+
+extern VALUE rb_cWXGauge;
+
+DLL_LOCAL void Init_WXGauge(VALUE rb_mWX);
+
+#endif /* WXGAUGE_HPP_ */

data/ext/wxGrid.cpp

@@ -0,0 +1,250 @@
+/*
+ * wxGrid.cpp
+ *
+ *  Created on: 15.04.2012
+ *      Author: hanmac
+ */
+
+
+#include "wxControl.hpp"
+#include "wxGrid.hpp"
+#include "wxGridTable.hpp"
+#include "wxGridCellRenderer.hpp"
+#include "wxGridCellAttr.hpp"
+
+#include "wxColor.hpp"
+#include "wxFont.hpp"
+#include "wxPen.hpp"
+
+VALUE rb_cWXGrid, rb_cWXGridEvent;
+#if wxUSE_GRID
+
+#define _self unwrap<wxGrid*>(self)
+
+namespace RubyWX {
+namespace Grid {
+
+macro_attr(Table,wxGridTableBase*)
+macro_attr(GridLineColour,wxColour)
+macro_attr(LabelBackgroundColour,wxColour)
+macro_attr(LabelTextColour,wxColour)
+macro_attr(LabelFont,wxFont)
+
+macro_attr(CellHighlightColour,wxColour)
+macro_attr(CellHighlightPenWidth,int)
+macro_attr(CellHighlightROPenWidth,int)
+
+macro_attr(RowLabelSize,int)
+macro_attr(ColLabelSize,int)
+
+macro_attr(DefaultRowSize,int)
+macro_attr(DefaultColSize,int)
+
+macro_attr(ColMinimalAcceptableWidth,int)
+macro_attr(RowMinimalAcceptableHeight,int)
+
+
+//macro_attr(SelectionMode,wxGrid::wxGridSelectionModes)
+
+macro_attr(SelectionBackground,wxColour)
+macro_attr(SelectionForeground,wxColour)
+
+macro_attr(DefaultCellBackgroundColour,wxColour)
+macro_attr(DefaultCellTextColour,wxColour)
+macro_attr(DefaultCellFont,wxFont)
+macro_attr(DefaultCellOverflow,bool)
+
+macro_attr(DefaultRenderer,wxGridCellRenderer*)
+//macro_attr(DefaultEditor,wxGridCellEditor*)
+
+macro_attr_bool2(Editable,EnableEditing)
+
+singlereturn(GetSelectedCells)
+singlereturn(GetSelectedRows)
+singlereturn(GetSelectedCols)
+
+singlereturn(GetDefaultGridLinePen)
+
+singlereturn(GetSelectionBlockTopLeft);
+singlereturn(GetSelectionBlockBottomRight);
+
+singlereturn(IsSelection)
+
+singlefunc(AutoSize)
+
+APP_PROTECT(wxGrid)
+
+DLL_LOCAL VALUE _initialize(int argc,VALUE *argv,VALUE self)
+{
+	VALUE parent,hash,name;
+	rb_scan_args(argc, argv, "11:",&parent,&name,&hash);
+
+	if(!_created) {
+#if wxUSE_XRC
+		if(!loadxrc(_self,name,unwrap<wxWindow*>(parent)))
+#endif
+		{
+			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);
+			_self->SetMargins(0,0);
+		}
+		
+	}
+
+	rb_call_super(argc,argv);
+
+	return self;
+}
+DLL_LOCAL VALUE _getRowSize(VALUE self,VALUE row)
+{
+	return INT2NUM(_self->GetRowSize(NUM2INT(row)));
+}
+
+DLL_LOCAL VALUE _getColSize(VALUE self,VALUE row)
+{
+	return INT2NUM(_self->GetColSize(NUM2INT(row)));
+}
+
+DLL_LOCAL VALUE _getCellSize(VALUE self,VALUE x,VALUE y)
+{
+	return wrap(_self->GetCellSize(wxGridCellCoords(NUM2INT(x),NUM2INT(y))));
+}
+
+DLL_LOCAL VALUE _getRowGridLinePen(VALUE self,VALUE row)
+{
+	return wrap(_self->GetRowGridLinePen(NUM2INT(row)));
+}
+
+DLL_LOCAL VALUE _getColGridLinePen(VALUE self,VALUE row)
+{
+	return wrap(_self->GetColGridLinePen(NUM2INT(row)));
+}
+
+
+}
+}
+
+#endif
+
+DLL_LOCAL void Init_WXGrid(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_cWXPanel = rb_define_class_under(rb_mWX,"Panel",rb_cWXControl);
+
+	rb_define_attr(rb_cWXGrid,"table",1,1);
+	rb_define_attr(rb_cWXGrid,"line_color",1,1);
+	rb_define_attr(rb_cWXGrid,"label_background_color",1,1);
+	rb_define_attr(rb_cWXGrid,"label_text_color",1,1);
+	rb_define_attr(rb_cWXGrid,"label_font",1,1);
+
+	rb_define_attr(rb_cWXGrid,"row_label_size",1,1);
+	rb_define_attr(rb_cWXGrid,"col_label_size",1,1);
+
+	rb_define_attr(rb_cWXGrid,"default_row_size",1,1);
+	rb_define_attr(rb_cWXGrid,"default_col_size",1,1);
+
+
+	rb_define_attr(rb_cWXGrid,"highlight_color",1,1);
+	rb_define_attr(rb_cWXGrid,"highlight_penwidth",1,1);
+	rb_define_attr(rb_cWXGrid,"highlight_ropen_width",1,1);
+
+	rb_define_attr(rb_cWXGrid,"default_renderer",1,1);
+
+	rb_define_attr(rb_cWXGrid,"minimal_width",1,1);
+	rb_define_attr(rb_cWXGrid,"minimal_height",1,1);
+
+	rb_define_attr(rb_cWXGrid,"editable",1,1);
+
+#endif
+
+#if wxUSE_GRID
+	using namespace RubyWX::Grid;
+	rb_cWXGrid = rb_define_class_under(rb_mWX,"Grid",rb_cWXPanel);
+	rb_define_alloc_func(rb_cWXGrid,_alloc);
+
+	rb_define_method(rb_cWXGrid,"initialize",RUBY_METHOD_FUNC(_initialize),-1);
+
+	rb_define_attr_method(rb_cWXGrid,"table",_getTable,_setTable);
+	rb_define_attr_method(rb_cWXGrid,"line_color",_getGridLineColour,_setGridLineColour);
+	rb_define_attr_method(rb_cWXGrid,"label_background_color",_getLabelBackgroundColour,_setLabelBackgroundColour);
+	rb_define_attr_method(rb_cWXGrid,"label_text_color",_getLabelTextColour,_setLabelTextColour);
+	rb_define_attr_method(rb_cWXGrid,"label_font",_getLabelFont,_setLabelFont);
+
+	rb_define_attr_method(rb_cWXGrid,"row_label_size",_getRowLabelSize,_setRowLabelSize);
+	rb_define_attr_method(rb_cWXGrid,"col_label_size",_getColLabelSize,_setColLabelSize);
+
+	rb_define_attr_method(rb_cWXGrid,"default_row_size",_getDefaultRowSize,_setDefaultRowSize);
+	rb_define_attr_method(rb_cWXGrid,"default_col_size",_getDefaultColSize,_setDefaultColSize);
+
+
+	rb_define_attr_method(rb_cWXGrid,"highlight_color",_getCellHighlightColour,_setCellHighlightColour);
+	rb_define_attr_method(rb_cWXGrid,"highlight_penwidth",_getCellHighlightPenWidth,_setCellHighlightPenWidth);
+	rb_define_attr_method(rb_cWXGrid,"highlight_ropen_width",_getCellHighlightROPenWidth,_setCellHighlightROPenWidth);
+
+	rb_define_attr_method(rb_cWXGrid,"default_renderer",_getDefaultRenderer,_setDefaultRenderer);
+
+	rb_define_attr_method(rb_cWXGrid,"minimal_width",_getColMinimalAcceptableWidth,_setColMinimalAcceptableWidth);
+	rb_define_attr_method(rb_cWXGrid,"minimal_height",_getRowMinimalAcceptableHeight,_setRowMinimalAcceptableHeight);
+
+
+	rb_define_attr_method(rb_cWXGrid,"editable",_getEditable,_setEditable);
+
+	rb_define_method(rb_cWXGrid,"autosize",RUBY_METHOD_FUNC(_AutoSize),0);
+	rb_define_method(rb_cWXGrid,"cellsize",RUBY_METHOD_FUNC(_getCellSize),2);
+
+	rb_define_method(rb_cWXGrid,"row_size",RUBY_METHOD_FUNC(_getRowSize),1);
+	rb_define_method(rb_cWXGrid,"col_size",RUBY_METHOD_FUNC(_getColSize),1);
+
+	rb_define_method(rb_cWXGrid,"row_grid_line_pen",RUBY_METHOD_FUNC(_getRowGridLinePen),1);
+	rb_define_method(rb_cWXGrid,"col_grid_line_pen",RUBY_METHOD_FUNC(_getColGridLinePen),1);
+
+
+	rb_define_method(rb_cWXGrid,"selection?",RUBY_METHOD_FUNC(_IsSelection),0);
+
+	rb_define_method(rb_cWXGrid,"selected_cells",RUBY_METHOD_FUNC(_GetSelectedCells),0);
+	rb_define_method(rb_cWXGrid,"selected_rows",RUBY_METHOD_FUNC(_GetSelectedRows),0);
+	rb_define_method(rb_cWXGrid,"selected_cols",RUBY_METHOD_FUNC(_GetSelectedCols),0);
+
+	rb_define_method(rb_cWXGrid,"selected_topleft",RUBY_METHOD_FUNC(_GetSelectionBlockTopLeft),0);
+	rb_define_method(rb_cWXGrid,"selected_bottomright",RUBY_METHOD_FUNC(_GetSelectionBlockBottomRight),0);
+
+
+	rb_cWXGridEvent = rb_define_class_under(rb_cWXEvent,"Grid",rb_cWXEvent);
+
+	registerEventType("grid_cell_left_click", wxEVT_GRID_CELL_LEFT_CLICK, rb_cWXGridEvent );
+	registerEventType("grid_cell_right_click", wxEVT_GRID_CELL_RIGHT_CLICK, rb_cWXGridEvent );
+	registerEventType("grid_cell_left_dclick", wxEVT_GRID_CELL_LEFT_DCLICK, rb_cWXGridEvent );
+	registerEventType("grid_cell_right_dclick", wxEVT_GRID_CELL_RIGHT_DCLICK, rb_cWXGridEvent );
+	registerEventType("grid_label_left_click", wxEVT_GRID_LABEL_LEFT_CLICK, rb_cWXGridEvent );
+	registerEventType("grid_label_right_click", wxEVT_GRID_LABEL_RIGHT_CLICK, rb_cWXGridEvent );
+	registerEventType("grid_label_left_dclick", wxEVT_GRID_LABEL_LEFT_DCLICK, rb_cWXGridEvent );
+	registerEventType("grid_label_right_dclick", wxEVT_GRID_LABEL_RIGHT_DCLICK, rb_cWXGridEvent );
+	//registerEventType("", wxEVT_GRID_ROW_SIZE, wxGridSizeEvent );
+	//registerEventType("", wxEVT_GRID_COL_SIZE, wxGridSizeEvent );
+	//registerEventType("", wxEVT_GRID_RANGE_SELECT, wxGridRangeSelectEvent );
+	registerEventType("grid_cell_changing", wxEVT_GRID_CELL_CHANGING, rb_cWXGridEvent );
+	registerEventType("grid_cell_changed", wxEVT_GRID_CELL_CHANGED, rb_cWXGridEvent );
+	registerEventType("grid_select_cell", wxEVT_GRID_SELECT_CELL, rb_cWXGridEvent );
+	registerEventType("grid_editor_shown", wxEVT_GRID_EDITOR_SHOWN, rb_cWXGridEvent );
+	registerEventType("grid_editor_hidden", wxEVT_GRID_EDITOR_HIDDEN, rb_cWXGridEvent );
+	//registerEventType("", wxEVT_GRID_EDITOR_CREATED, wxGridEditorCreatedEvent );
+	registerEventType("grid_cell_begin_drag", wxEVT_GRID_CELL_BEGIN_DRAG, rb_cWXGridEvent );
+	registerEventType("grid_col_move", wxEVT_GRID_COL_MOVE, rb_cWXGridEvent );
+	registerEventType("grid_col_sort", wxEVT_GRID_COL_SORT, rb_cWXGridEvent );
+
+	registerInfo<wxGrid>(rb_cWXGrid);
+
+#endif
+}
+
+
+

data/ext/wxGrid.hpp

@@ -0,0 +1,43 @@
+/*
+ * wxGrid.hpp
+ *
+ *  Created on: 15.04.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXGRID_HPP_
+#define WXGRID_HPP_
+
+#include "wxEvtHandler.hpp"
+
+extern VALUE rb_cWXGrid;
+void Init_WXGrid(VALUE rb_mWX);
+
+#if wxUSE_GRID
+#include <wx/grid.h>
+
+template <>
+inline VALUE wrap< wxGridCellCoords >(const wxGridCellCoords& coord)
+{
+	VALUE result = rb_ary_new();
+	rb_ary_push(result,INT2NUM(coord.GetCol()));
+	rb_ary_push(result,INT2NUM(coord.GetRow()));
+	return result;
+}
+
+
+template <>
+inline VALUE wrap< wxGridCellCoordsArray >(const wxGridCellCoordsArray &st )
+{
+	VALUE ary = rb_ary_new();
+
+	for(size_t i = 0; i < st.Count() ; ++i)
+	{
+		rb_ary_push(ary,wrap(st.Item(i)));
+	}
+	return ary;
+}
+
+#endif
+
+#endif /* WXGRID_HPP_ */

data/ext/wxGridCellAttr.cpp

@@ -0,0 +1,68 @@
+/*
+ * wxGridCellAttr.cpp
+ *
+ *  Created on: 19.04.2012
+ *      Author: hanmac
+ */
+
+#include "wxApp.hpp"
+#include "wxGridCellAttr.hpp"
+
+#include "wxColor.hpp"
+#include "wxFont.hpp"
+
+VALUE rb_cWXGridCellAttr;
+
+#if wxUSE_GRID
+
+template <>
+VALUE wrap< wxGridCellAttr >(wxGridCellAttr* window)
+{
+	return wrapTypedPtr(window,rb_cWXGridCellAttr);
+}
+
+
+#define _self unwrap<wxGridCellAttr*>(self)
+
+
+
+namespace RubyWX {
+namespace GridCellAttr {
+
+macro_attr(TextColour,wxColour)
+macro_attr(BackgroundColour,wxColour)
+macro_attr(Font,wxFont)
+
+APP_PROTECT(wxGridCellAttr)
+
+}
+}
+
+#endif
+
+DLL_LOCAL void Init_WXGridCellAttr(VALUE rb_mWX)
+{
+#if 0
+	rb_define_attr(rb_cWXGridCellAttr,"text_color",1,1);
+	rb_define_attr(rb_cWXGridCellAttr,"background_color",1,1);
+	rb_define_attr(rb_cWXGridCellAttr,"font",1,1);
+
+#endif
+
+#if wxUSE_GRID
+	using namespace RubyWX::GridCellAttr;
+	rb_cWXGridCellAttr = rb_define_class_under(rb_mWX,"GridCellAttr",rb_cObject);
+	rb_define_alloc_func(rb_cWXGridCellAttr,_alloc);
+
+	//TODO make GridCellAttr copyable
+	rb_undef_method(rb_cWXGridCellAttr,"initialize_copy");
+	rb_undef_method(rb_cWXGridCellAttr,"_load");
+	rb_undef_method(rb_cWXGridCellAttr,"_dump");
+
+	rb_define_attr_method(rb_cWXGridCellAttr,"text_color",_getTextColour,_setTextColour);
+	rb_define_attr_method(rb_cWXGridCellAttr,"background_color",_getBackgroundColour,_setBackgroundColour);
+	rb_define_attr_method(rb_cWXGridCellAttr,"font",_getFont,_setFont);
+
+	registerType<wxGridCellAttr>(rb_cWXGridCellAttr);
+#endif
+}

data/ext/wxGridCellAttr.hpp

@@ -0,0 +1,26 @@
+/*
+ * wxGridCellAttr.hpp
+ *
+ *  Created on: 19.04.2012
+ *      Author: hanmac
+ */
+
+#ifndef WXGRIDCELLATTR_HPP_
+#define WXGRIDCELLATTR_HPP_
+
+#include "main.hpp"
+
+extern VALUE rb_cWXGridCellAttr;
+void Init_WXGridCellAttr(VALUE rb_mWX);
+
+#if wxUSE_GRID
+#include <wx/grid.h>
+
+template <>
+VALUE wrap< wxGridCellAttr >(wxGridCellAttr* window);
+
+#endif
+
+
+
+#endif /* WXGRIDCELLATTR_HPP_ */

data/ext/wxGridCellRenderer.cpp

@@ -0,0 +1,120 @@
+/*
+ * wxGridCellRenderer.cpp
+ *
+ *  Created on: 18.04.2012
+ *      Author: hanmac
+ */
+
+#include "wxEvtHandler.hpp"
+#include "wxGridCellAttr.hpp"
+#include "wxRect.hpp"
+#include "wxDC.hpp"
+
+#define mRuby static_cast<RubyClientData*>(GetClientObject())->mRuby
+
+VALUE rb_cWXGridCellRenderer;
+
+#if wxUSE_GRID
+
+template <>
+VALUE wrap< wxGridCellRenderer >(wxGridCellRenderer* window)
+{
+	return wrapTypedPtr(window,rb_cWXGridCellRenderer);
+}
+
+class RubyGridCellRenderer : public wxGridCellRenderer
+{
+public :
+	void Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect& rect, int row, int col, bool isSelected)
+	{
+		wxGridCellRenderer::Draw(grid,attr,dc,rect,row,col,isSelected);
+		rb_funcall(mRuby,rb_intern("draw"),7,wrap(&grid),wrap(&attr),wrap(&dc),wrap(rect),INT2NUM(row),INT2NUM(col),wrap(isSelected));
+	}
+
+	wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, int row, int col)
+	{
+		return unwrap<wxSize>(rb_funcall(mRuby,rb_intern("best_size"),5,wrap(&grid),wrap(&attr),wrap(&dc),INT2NUM(row),INT2NUM(col)));
+	}
+	wxGridCellRenderer *Clone() const
+	{
+		return new RubyGridCellRenderer;
+	}
+};
+
+
+template <>
+wxGridCellRenderer* unwrap<wxGridCellRenderer*>(const VALUE &arg)
+{
+	return unwrapTypedPtr<wxGridCellRenderer>(arg,rb_cWXGridCellRenderer);
+}
+
+
+#define typeRenderer(type) \
+VALUE rb_cWXGridCell##type##Renderer; \
+class RubyGridCell##type##Renderer : public wxGridCell##type##Renderer \
+{\
+public :\
+	void Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect& rect, int row, int col, bool isSelected)\
+	{\
+		VALUE self = mRuby;\
+		if(!rubycall)\
+		{\
+			rubycall = true;\
+			rb_funcall(self,rb_intern("draw"),7,wrap(&grid),wrap(&attr),wrap(&dc),wrap(rect),INT2NUM(row),INT2NUM(col),wrap(isSelected));\
+			rubycall = false;\
+		}else\
+			wxGridCell##type##Renderer::Draw(grid,attr,dc,rect,row,col,isSelected);\
+	}\
+\
+	wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, int row, int col)\
+	{\
+		VALUE self = mRuby;\
+		if(!rubycall)\
+		{\
+			rubycall = true;\
+			wxSize size(unwrap<wxSize>(rb_funcall(self,rb_intern("best_size"),7,wrap(&grid),wrap(&attr),wrap(&dc),INT2NUM(row),INT2NUM(col))));\
+			rubycall = false;\
+			return size;\
+		}else\
+			return wxGridCell##type##Renderer::GetBestSize(grid,attr,dc,row,col);\
+\
+	}\
+private:\
+bool rubycall;\
+};
+
+typeRenderer(String)
+typeRenderer(AutoWrapString)
+
+typeRenderer(Bool)
+typeRenderer(Float)
+typeRenderer(Number)
+typeRenderer(Enum)
+
+#if wxUSE_DATETIME
+typeRenderer(DateTime)
+#endif
+
+namespace RubyWX {
+namespace GridCellRenderer {
+//macro_attr(Path,wxString)
+
+APP_PROTECT(RubyGridCellRenderer);
+
+}
+}
+
+#endif
+
+DLL_LOCAL void Init_WXGridCellRenderer(VALUE rb_mWX)
+{
+#if wxUSE_GRID
+	using namespace RubyWX::GridCellRenderer;
+	rb_cWXGridCellRenderer = rb_define_class_under(rb_mWX,"GridCellRenderer",rb_cObject);
+	rb_define_alloc_func(rb_cWXGridCellRenderer,_alloc);
+
+	registerType<wxGridCellRenderer>(rb_cWXGridCellRenderer);
+#endif
+}
+
+