rwx 0.0.1.dev

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7daea4298f8fa4179a561773567028921b532dfa
+  data.tar.gz: 086761364b235c6e588cdccfe7642861dc17b2f7
+SHA512:
+  metadata.gz: 5b613965f1aeb188536fa7ad27cb6b9dca2d69a2bcf0283c6cc23339414335142d6a8c4e2c39372aab544a5b2c5dc94dbb272b81733d2367b68238f9810c65c4
+  data.tar.gz: 0ee62eed5e4e037f9f88f171de4fbdb85bfbed0656887a02f01fb1b0dcbf5cbc77b356d6ff102e309a6718751b8346596d6d133a359e7071544bab82f7ccf452

data/.gitignore

@@ -0,0 +1,49 @@
+# Compiled Object files
+*.slo
+*.lo
+*.o
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.bundle
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+
+
+#eclipse project files
+.cproject
+.project
+.settings
+
+# Ignore mkmf-generated files
+ext/Makefile
+ext/extconf.h
+ext/mkmf.log
+
+#ignore temp files
+*.*~
+
+# Generated Packages
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+/Debug

data/Rakefile

@@ -0,0 +1,100 @@
+# -*- mode: ruby; coding: utf-8 -*-
+gem "rdoc"
+require "tmpdir"
+require "rake"
+require "rake/clean"
+require "rake/testtask"
+require "rubygems/package_task"
+require "rdoc/task"
+
+begin
+require 'rake/extensiontask'
+rescue LoadError
+end
+
+ENV["RDOCOPT"] = "" if ENV["RDOCOPT"]
+if RDoc::VERSION < "4.1"
+	TMPSRCDIR = Dir.mktmpdir
+	CLEAN.include(TMPSRCDIR)
+end
+CLOBBER.include("rdoc")
+
+
+load "rwx.gemspec"
+
+Gem::PackageTask.new(GEMSPEC) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+  pkg.need_tar_bz2 = true
+  pkg.need_tar_gz = true
+end
+
+unless Rake.const_defined?(:ExtensionTask)
+  desc "Compiles rwx, outputting ext/rwx.so"
+  task :compile do
+    cd "ext"
+    ruby "extconf.rb"
+    sh "make"
+    cd ".."
+  end
+else
+  Rake::ExtensionTask.new('rwx',GEMSPEC) do |t|
+    t.ext_dir = "ext"
+    t.source_pattern = "*.cpp"
+  end
+  
+  Rake::ExtensionTask.new('rwx',GEMSPEC) do |t|
+    t.ext_dir = "ext"
+    t.source_pattern = "*.cpp"
+    
+    t.cross_compile = true                # enable cross compilation (requires cross compile toolchain)
+    t.cross_platform = 'i386-mswin32'     # forces the Windows platform instead of the default one
+  end
+end
+
+Rake::TestTask.new do |t|
+  t.verbose = true
+end
+
+RDoc::Task.new do |rdoc|
+  rdoc.title = "rwx RDocs"
+  rdoc.main = "README.rdoc"
+if RDoc::VERSION < "4.1"
+  rdoc.rdoc_files.include("*.rdoc", TMPSRCDIR)
+  # We will have another 'rdoc' task that depends on this task
+  rdoc.name = :docs
+else
+  rdoc.rdoc_files.include("*.rdoc", "ext/*.cpp")
+end
+  rdoc.rdoc_dir = "rdoc"
+end
+
+if RDoc::VERSION < "4.1"
+
+# This task removes the DLL_LOCAL statements temporarily to
+# make RDoc work properly. The stripped sources are to be
+# found in TMPSRCDIR afterwards.
+task :prepare_sources do
+  rm_r TMPSRCDIR if File.directory?(TMPSRCDIR)
+
+  mkdir TMPSRCDIR
+  
+  #cp "ext/*.cpp", TMPSRCDIR
+  Dir["ext/*.cpp"].each do |path|
+    path = path[/\/(.+)/,1]
+    puts "Removing DLL_LOCAL in #{path}"
+
+    File.write("#{TMPSRCDIR}/#{path}",File.read("ext/#{path}").gsub(/DLL_LOCAL\s?/, ""))
+  end
+end
+
+# Removes the temporary directory created by :prepare_sources.
+task :clean_sources do
+  rm_r TMPSRCDIR
+end
+
+desc "Generate the RDoc documentation."
+task :rdoc => [:prepare_sources, :docs, :clean_sources]
+
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1-dev

data/ext/extconf.rb

@@ -0,0 +1,112 @@
+require "mkmf"
+
+# add check for member function, does need default constructor for class
+def have_member_func(klass,member,header)
+	if have_func("#{klass}().#{member}()",header)
+		$defs[-1] = "-DHAVE_#{klass.tr_cpp}_#{member.tr_cpp}" 
+	end
+end
+
+dir_config "rwx"
+
+if(wx_config = find_executable('wx-config'))
+	
+	if `#{wx_config} --version`.chomp < "3.0.0"
+		abort("wx version outdated, please update to 3.0.0 or newer")
+	end
+	
+	# An ruby extension does need to be build against
+	# the same compiler as ruby was
+	unless CONFIG["CC"] && find_executable(CONFIG["CC"])
+		abort("C compiler not found!")
+	end
+	unless CONFIG["CXX"] && find_executable(CONFIG["CXX"])
+		abort("C++ compiler not found!")
+	end
+	
+	cc = `#{wx_config} --cc`.chomp
+	unless cc == CONFIG["CC"]
+		warn("CC compiler missmatch %s == %s" % [cc, CONFIG["CC"]])
+	end
+	
+	cxx = `#{wx_config} --cxx`.chomp
+	unless cxx == CONFIG["CXX"]
+		warn("CXX compiler missmatch %s == %s" % [cxx, CONFIG["CXX"]])
+	end
+	
+	#earlier versions of ruby does not have that constant
+	$CXXFLAGS = CONFIG["CXXFLAGS"] unless defined?($CXXFLAGS)
+	
+	#for some function add the base classes
+	extra_libs = []
+	case `#{wx_config} --basename`
+	when /gtk2/
+		extra_libs << "gtk+-x11-2.0" << "gdk-x11-2.0"
+	when /gtk3/
+		extra_libs << "gtk+-x11-3.0" << "gdk-x11-3.0"
+	end
+	
+	extra_libs.each {|l|
+		pkg = pkg_config(l)
+		#because pkg forgot to add the include paths to cxx flags
+		$CXXFLAGS << pkg[0] if pkg && !$CXXFLAGS[pkg[0]]
+	}
+	
+	all = " -fvisibility-inlines-hidden"
+	$CFLAGS << all << " -x c++ -g -Wall "
+	$CXXFLAGS << all << " -g -Wall "
+	$CPPFLAGS << all << " -g "
+	$LDFLAGS << all << " "
+	
+	# add the wx-config flags
+	$CFLAGS << `#{wx_config} --cflags`.chomp
+	$CXXFLAGS << `#{wx_config} --cxxflags`.chomp
+	$CPPFLAGS << `#{wx_config} --cppflags`.chomp
+	$LDFLAGS << `#{wx_config} --libs all`.chomp
+	
+	with_cflags(" -x c++ ") {
+		# need c++ for some of the tests
+		RbConfig::CONFIG["CC"] = CONFIG["CXX"]
+		
+		have_header("wx/preferences.h")
+		
+		#check for better Bind commmand
+		unless have_macro("wxHAS_EVENT_BIND","wx/wx.h")
+			abort("need wxHAS_EVENT_BIND, update your compiler!")
+		end
+		
+		#check for Default-Constructors
+		have_func("wxContextHelpButton()","wx/cshelp.h")
+		have_func("wxNumberEntryDialog()","wx/numdlg.h")
+		have_func("wxPasswordEntryDialog()","wx/textdlg.h")
+		have_func("wxProgressDialog()","wx/progdlg.h")
+		have_func("wxMessageDialog()","wx/msgdlg.h")
+		have_func("wxGenericMessageDialog()","wx/generic/msgdlgg.h")
+		have_func("wxRichMessageDialog()","wx/richmsgdlg.h")
+		
+		#check for instance methods, that classes need to have default constuctor
+		have_member_func("wxFontPickerCtrl","GetSelectedColour","wx/fontpicker.h")
+		have_member_func("wxInfoBar","GetButtonCount","wx/infobar.h")
+		
+		#check for enum flags
+		have_const("wxFD_NO_FOLLOW","wx/filedlg.h")
+		have_const("wxDIRCTRL_DEFAULT_STYLE",["wx/wx.h", "wx/dirctrl.h"])
+		
+	}
+else
+		abort("wx-config executable not found!")
+
+end
+
+$defs.push("-DRUBY_UNTYPED_DATA_WARNING=1")
+
+#drop some of the warn flags because they are not valid for C++
+CONFIG["warnflags"].gsub!(
+	Regexp.union(
+		"-Wdeclaration-after-statement",
+		"-Wimplicit-function-declaration",
+		"-Wextra" #wxAUI is a bit buggy
+	), "")
+
+create_header
+create_makefile "rwx"

data/ext/main.cpp

@@ -0,0 +1,432 @@
+/*
+ * main.cpp
+ *
+ *  Created on: 04.05.2012
+ *      Author: hanmac
+ */
+
+#include "main.hpp"
+
+#include <wx/arrstr.h>
+
+#include <wx/filename.h>
+
+infoholdertype infoklassholder;
+typeholdertype typeklassholder;
+
+enumregistertype enumregister;
+
+datatypeholdertype datatypeholder;
+datatypeholdertype datatypeholder_const;
+
+VALUE global_holder;
+
+typedef std::map<VALUE,std::size_t> ref_countertype;
+ref_countertype ref_counter;
+
+
+void rwx_refobject(VALUE object)
+{
+	if(ref_counter[object] == 0)
+		rb_hash_aset(global_holder,INT2NUM(object),object);
+	ref_counter[object]++;
+}
+
+bool rwx_unrefobject(VALUE object)
+{
+	if(ref_counter[object] != 0)
+		ref_counter[object]--;
+	if(ref_counter[object] == 0) {
+		rb_hash_delete(global_holder,INT2NUM(object));
+		return true;
+	}
+	return false;
+}
+
+void registerDataType(VALUE klass, RUBY_DATA_FUNC freefunc, size_t (*sizefunc)(const void *))
+{
+	if(!NIL_P(klass))
+	{
+		rb_data_type_t str = {
+			rb_class2name(klass),
+			{0, freefunc, sizefunc,},
+			unwrapDataType(RCLASS_SUPER(klass)), NULL,
+		};
+
+		datatypeholder[klass] = str;
+		if(freefunc) {
+			rb_data_type_t str_const = {
+				(std::string(rb_class2name(klass)) + "(const)").c_str(),
+				{0, 0, sizefunc,},
+				&datatypeholder[klass], NULL,
+			};
+			datatypeholder_const[klass] = str_const;
+		}else {
+			datatypeholder_const[klass] = str;
+		}
+	}
+}
+
+void registerDataType(VALUE klass)
+{
+	registerDataType(klass, RUBY_TYPED_NEVER_FREE, NULL);
+}
+
+void* unwrapTypedPtr(const VALUE &obj, rb_data_type_t* rbdata)
+{
+	if(NIL_P(obj))
+		return NULL;
+
+	if(!rbdata) {
+		rb_raise(rb_eTypeError,"%s unknown datatype", rb_obj_classname(obj));
+		return NULL;
+	}
+	void* data = Check_TypedStruct(obj, rbdata);
+	if(!data) {
+		rb_raise(
+			rb_eRuntimeError, "destroyed object of %s", rb_obj_classname(obj)
+		);
+		return NULL;
+	}
+	return data;
+
+}
+
+VALUE wrapClass(const wxClassInfo * info)
+{
+	infoholdertype::iterator it = infoklassholder.find(info);
+	if(it != infoklassholder.end())
+		return it->second;
+	if(const wxClassInfo *base = info->GetBaseClass1())
+		return wrapClass(base);
+	return Qnil;
+}
+
+rb_data_type_t* unwrapDataType(const VALUE& klass)
+{
+	if(klass == rb_cObject)
+		return NULL;
+	datatypeholdertype::iterator it = datatypeholder.find(klass);
+	if(it != datatypeholder.end())
+		return &it->second;
+	return unwrapDataType(RCLASS_SUPER(klass));
+}
+
+
+VALUE wrapTypedPtr(void *arg,VALUE klass)
+{
+	if(arg){
+		rb_data_type_t* datatype = unwrapDataType(klass);
+		if(!datatype)
+			rb_fatal("%s unknown datatype",rb_class2name(klass));
+
+		return TypedData_Wrap_Struct(klass, datatype, arg);
+	}
+	return Qnil;
+}
+
+#define type_wrap(t,get,set) \
+template <>\
+t unwrap< t >(const VALUE &val )\
+{\
+	return get(val);\
+}\
+template <>\
+VALUE wrap< t >(const t &st )\
+{\
+	return set(st);\
+}\
+
+#define type_wrap_array(t) \
+template <>\
+VALUE wrap< t >(const t &st )\
+{\
+	VALUE ary = rb_ary_new();\
+	for(t::const_iterator it = st.begin(); it != st.end(); ++it)\
+		rb_ary_push(ary,wrap(*it));\
+	return ary;\
+}\
+template <>\
+t unwrap< t >(const VALUE &val )\
+{\
+	t arry;\
+	if(NIL_P(val))\
+		return arry;\
+	VALUE dp(rb_Array(val));\
+	std::size_t length = RARRAY_LEN(dp);\
+	for(std::size_t i = 0; i < length; ++i)\
+		arry.Add(unwrap<t::value_type>(RARRAY_AREF(dp,i)));\
+	return arry;\
+}
+
+template <>
+bool unwrap< bool >(const VALUE &val )
+{
+	return RTEST(val);
+}
+
+template <>
+VALUE wrap< bool >(const bool &st )
+{
+	return st ? Qtrue : Qfalse;
+}
+
+type_wrap(int,NUM2INT,INT2NUM)
+type_wrap(double,NUM2DBL,DBL2NUM)
+type_wrap(unsigned int,NUM2UINT,UINT2NUM)
+type_wrap(long,NUM2LONG,LONG2NUM)
+type_wrap(unsigned long,NUM2ULONG,ULONG2NUM)
+
+template <>
+VALUE wrap< wxString >(const wxString &st )
+{
+#ifdef HAVE_RUBY_ENCODING_H
+	return rb_enc_str_new(st.c_str(),strlen(st.c_str()),rb_utf8_encoding());
+#else
+	return rb_str_new2(st.c_str());
+#endif
+}
+template <>
+VALUE wrap< wxChar >(const wxChar &c )
+{
+	return wrap(wxString(c));
+}
+
+template <>
+char* unwrap< char* >(const VALUE &val )
+{
+	if(NIL_P(val))
+		return NULL;
+	if (rb_obj_is_kind_of(val, rb_cString)){
+		return RSTRING_PTR(val);
+	}
+	else
+		return unwrap< char* >(rb_String(val));
+}
+
+template <>
+wxString unwrap< wxString >(const VALUE &val )
+{
+	if(NIL_P(val))
+		return wxEmptyString;
+	else
+		return wxString(unwrap< char* >(val));
+}
+
+type_wrap_array(wxArrayString)
+type_wrap_array(wxArrayInt)
+
+template <>
+VALUE wrap< wxDateTime >(const wxDateTime &st )
+{
+	return rb_time_new(st.GetTicks(),st.GetMillisecond() * 10);
+}
+
+template <>
+wxDateTime unwrap< wxDateTime >(const VALUE &val )
+{
+	wxDateTime result;
+	result.SetToCurrent();
+	result.MakeTimezone(
+		NUM2UINT(rb_funcall(val,rb_intern("gmt_offset"),0)) - 3600,
+		RTEST(rb_funcall(val,rb_intern("dst?"),0))
+	);
+
+	result.Set(
+		NUM2UINT(rb_funcall(val,rb_intern("day"),0)),
+		(wxDateTime::Month)(NUM2UINT(rb_funcall(val,rb_intern("month"),0))-1),
+		NUM2UINT(rb_funcall(val,rb_intern("year"),0)),
+		NUM2UINT(rb_funcall(val,rb_intern("hour"),0)),
+		NUM2UINT(rb_funcall(val,rb_intern("min"),0)),
+		NUM2UINT(rb_funcall(val,rb_intern("sec"),0)),
+		NUM2UINT(rb_funcall(val,rb_intern("usec"),0)) / 1000
+	);
+	return result;
+}
+
+enumtype* registerEnum(const std::string& name,const std::string& type ,int def)
+{
+	enumtype *etype = new enumtype;
+	enumregister.insert(std::make_pair(type,etype));
+	etype->name = name;
+	etype->allow_array = true;
+	etype->defaults = def;
+	return etype;
+}
+
+
+VALUE wrapenum(const int &arg, const std::string& name)
+{
+	enumtype::value_type &enummap = enumregister[name]->values;
+	enumtype::value_type::iterator it = enummap.find(arg);
+	if(it != enummap.end())
+		return ID2SYM(it->second);
+	bool found = false;
+
+	int carg(arg);
+
+	VALUE result = rb_ary_new();
+	for(it = enummap.begin();it != enummap.end();++it)
+	{
+		if((carg & it->first) != 0)
+		{
+			found = true;
+			rb_ary_push(result,ID2SYM(it->second));
+			carg &= ~it->first;
+		}
+	}
+	return found ? result : Qnil;
+}
+
+int unwrapenum(const VALUE &arg, const std::string& name)
+{
+	enumregistertype::iterator it = enumregister.find(name);
+	if(it != enumregister.end())
+	{
+		enumtype* etype = it->second;
+		if(NIL_P(arg))
+			return etype->defaults;
+		else if(SYMBOL_P(arg))
+		{
+			ID id(SYM2ID(arg));
+
+			for(enumtype::value_type::iterator it2 = etype->values.begin();
+					it2 != etype->values.end();
+					++it2)
+			{
+				if(it2->second == id)
+					return it2->first;
+			}
+			rb_raise(rb_eTypeError,"%s is not a %s-Enum.",rb_id2name(id),etype->name.c_str());
+		}else if(rb_obj_is_kind_of(arg,rb_cArray) && etype->allow_array )
+		{
+			int result = 0;
+			size_t count = RARRAY_LEN(arg);
+			for(size_t i = 0; i < count; ++i)
+				result = result | unwrapenum(RARRAY_AREF(arg,i),name);
+		}else
+			return NUM2INT(arg);
+	}
+	return 0;
+}
+
+int unwrap_iconflag(const VALUE &val,int mask)
+{
+	int result = unwrapenum(val,"icon_flag");
+
+	if((result & mask) != result)
+		rb_raise(rb_eTypeError,"%"PRIsVALUE" is not a in %d mask", val, mask);
+	
+	return result;
+
+}
+
+int unwrap_buttonflag(const VALUE& val)
+{
+	return unwrapenum(val,"button_flag");
+}
+
+bool check_file_loadable(const wxString& path)
+{
+	errno = 0;
+	wxFileName dir(wxPathOnly(path));
+	dir.MakeAbsolute(wxGetCwd());
+
+	wxFileName file(path);
+	file.MakeAbsolute(wxGetCwd());
+
+	if(dir.DirExists())
+	{
+		if(file.FileExists()){
+			if(!file.IsFileReadable())
+				errno = EACCES;
+		}else
+			errno = ENOENT;
+	}else
+		errno = ENOENT;
+
+	if(errno)
+	{
+		rb_sys_fail(path.c_str());
+		return false;
+	}
+	return true;
+
+}
+bool check_file_saveable(const wxString& path)
+{
+	errno = 0;
+
+	wxFileName dir(wxPathOnly(path));
+	dir.MakeAbsolute(wxGetCwd());
+
+	wxFileName file(path);
+	file.MakeAbsolute(wxGetCwd());
+	if(dir.DirExists())
+	{
+		if(file.FileExists() && !file.IsFileWritable())
+			errno = EACCES;
+		else if(!dir.IsDirWritable())
+			errno = EACCES;
+	}else
+		errno = ENOENT;
+
+	if(errno)
+	{
+		rb_sys_fail(path.c_str());
+		return false;
+	}
+	return true;
+}
+
+bool set_hash_flag_option(VALUE hash,const char* name,const int& flag,int& val)
+{
+	VALUE temp;
+	if(!NIL_P(temp=rb_hash_aref(hash,ID2SYM(rb_intern(name)))))
+	{
+		if(RTEST(temp))
+			val |= flag;
+		else
+			val &= ~flag;
+
+		return true;
+	}
+	return false;
+}
+
+bool nil_check(VALUE window,const char* type,bool raise)
+{
+	bool result = NIL_P(window);
+	if(result && raise)
+		rb_raise(rb_eTypeError,"%s can't be nil.",type);
+	return !result;
+}
+
+bool nil_check(VALUE window,VALUE klass, bool raise)
+{
+	return nil_check(window,rb_class2name(klass),raise);
+}
+
+bool nil_check(VALUE window, bool raise)
+{
+	return nil_check(window,"window",raise);
+}
+
+bool check_index(int &cidx,const std::size_t &count)
+{
+	bool raise = false;
+	if(cidx >= (int)count){
+		raise = true;
+	}else if(cidx < 0)
+	{
+		int tmp = cidx + count;
+		if(tmp > 0 && tmp <= (int)count)
+			cidx = tmp;
+		else
+			raise = true;
+	}
+
+	if(raise)
+		rb_raise(rb_eIndexError,"%d out of index",cidx);
+	return !raise;
+}