reflexion 0.1.19 → 0.1.23

data/ext/reflex/key_event.cpp

@@ -43,7 +43,7 @@ RUCY_DEF1(initialize_copy, obj)
 RUCY_END
 
 static
-RUCY_DEF0(type)
+RUCY_DEF0(get_type)
 {
 	CHECK;
 	return value(THIS->type);
@@ -51,7 +51,205 @@ RUCY_DEF0(type)
 RUCY_END
 
 static
-RUCY_DEF0(chars)
+RUCY_DEF0(get_key)
+{
+	CHECK;
+	switch (THIS->code)
+	{
+		#define CASE(key)         case Reflex::KEY_##key
+		#define SYMBOL1(name)     SYMBOL2(_##name, #name)
+		#define SYMBOL2(var, sym) {RUCY_SYMBOL(var, sym); return var.value();}
+
+		CASE(A): SYMBOL1(a);
+		CASE(B): SYMBOL1(b);
+		CASE(C): SYMBOL1(c);
+		CASE(D): SYMBOL1(d);
+		CASE(E): SYMBOL1(e);
+		CASE(F): SYMBOL1(f);
+		CASE(G): SYMBOL1(g);
+		CASE(H): SYMBOL1(h);
+		CASE(I): SYMBOL1(i);
+		CASE(J): SYMBOL1(j);
+		CASE(K): SYMBOL1(k);
+		CASE(L): SYMBOL1(l);
+		CASE(M): SYMBOL1(m);
+		CASE(N): SYMBOL1(n);
+		CASE(O): SYMBOL1(o);
+		CASE(P): SYMBOL1(p);
+		CASE(Q): SYMBOL1(q);
+		CASE(R): SYMBOL1(r);
+		CASE(S): SYMBOL1(s);
+		CASE(T): SYMBOL1(t);
+		CASE(U): SYMBOL1(u);
+		CASE(V): SYMBOL1(v);
+		CASE(W): SYMBOL1(w);
+		CASE(X): SYMBOL1(x);
+		CASE(Y): SYMBOL1(y);
+		CASE(Z): SYMBOL1(z);
+
+		CASE(0):
+		CASE(NUM_0): SYMBOL1(0);
+		CASE(1):
+		CASE(NUM_1): SYMBOL1(1);
+		CASE(2):
+		CASE(NUM_2): SYMBOL1(2);
+		CASE(3):
+		CASE(NUM_3): SYMBOL1(3);
+		CASE(4):
+		CASE(NUM_4): SYMBOL1(4);
+		CASE(5):
+		CASE(NUM_5): SYMBOL1(5);
+		CASE(6):
+		CASE(NUM_6): SYMBOL1(6);
+		CASE(7):
+		CASE(NUM_7): SYMBOL1(7);
+		CASE(8):
+		CASE(NUM_8): SYMBOL1(8);
+		CASE(9):
+		CASE(NUM_9): SYMBOL1(9);
+
+		CASE(MINUS):      SYMBOL1(minus);
+		CASE(EQUAL):      SYMBOL1(equal);
+		CASE(COMMA):      SYMBOL1(comma);
+		CASE(PERIOD):     SYMBOL1(period);
+		CASE(SEMICOLON):  SYMBOL1(semicolon);
+		CASE(QUOTE):      SYMBOL1(quote);
+		CASE(SLASH):      SYMBOL1(slash);
+		CASE(BACKSLASH):  SYMBOL1(backslash);
+		CASE(UNDERSCORE): SYMBOL1(underscore);
+		CASE(GRAVE):      SYMBOL1(grave);
+		CASE(YEN):        SYMBOL1(yen);
+		CASE(LBRACKET):   SYMBOL1(lbracket);
+		CASE(RBRACKET):   SYMBOL1(rbracket);
+
+		CASE(ENTER):
+		CASE(RETURN):     SYMBOL1(enter);
+		CASE(SPACE):      SYMBOL1(space);
+		CASE(TAB):        SYMBOL1(tab);
+		CASE(DELETE):     SYMBOL2(_delete, "delete");
+		CASE(BACKSPACE):  SYMBOL1(backspace);
+		//CASE(INSERT):     SYMBOL1(insert);
+		CASE(ESCAPE):     SYMBOL1(escape);
+
+		CASE(LEFT):     SYMBOL1(left);
+		CASE(RIGHT):    SYMBOL1(right);
+		CASE(UP):       SYMBOL1(up);
+		CASE(DOWN):     SYMBOL1(down);
+		CASE(HOME):     SYMBOL1(home);
+		CASE(END):      SYMBOL1(end);
+		CASE(PAGEUP):   SYMBOL1(pageup);
+		CASE(PAGEDOWN): SYMBOL1(pagedown);
+
+		CASE(LSHIFT):
+		CASE(RSHIFT):   SYMBOL1(shift);
+		CASE(LCONTROL):
+		CASE(RCONTROL): SYMBOL1(control);
+		//CASE(LALT):
+		//CASE(RALT):     SYMBOL1(alt);
+		//CASE(LWIN):
+		//CASE(RWIN):     SYMBOL1(win);
+		CASE(LCOMMAND):
+		CASE(RCOMMAND): SYMBOL1(command);
+		CASE(LOPTION):
+		CASE(ROPTION):  SYMBOL1(option);
+		CASE(FUNCTION): SYMBOL1(function);
+
+		CASE(F1):  SYMBOL1(f1);
+		CASE(F2):  SYMBOL1(f2);
+		CASE(F3):  SYMBOL1(f3);
+		CASE(F4):  SYMBOL1(f4);
+		CASE(F5):  SYMBOL1(f5);
+		CASE(F6):  SYMBOL1(f6);
+		CASE(F7):  SYMBOL1(f7);
+		CASE(F8):  SYMBOL1(f8);
+		CASE(F9):  SYMBOL1(f9);
+		CASE(F10): SYMBOL1(f10);
+		CASE(F11): SYMBOL1(f11);
+		CASE(F12): SYMBOL1(f12);
+		CASE(F13): SYMBOL1(f13);
+		CASE(F14): SYMBOL1(f14);
+		CASE(F15): SYMBOL1(f15);
+		CASE(F16): SYMBOL1(f16);
+		CASE(F17): SYMBOL1(f17);
+		CASE(F18): SYMBOL1(f18);
+		CASE(F19): SYMBOL1(f19);
+		CASE(F20): SYMBOL1(f20);
+		//CASE(F21): SYMBOL1(f21);
+		//CASE(F22): SYMBOL1(f22);
+		//CASE(F23): SYMBOL1(f23);
+		//CASE(F24): SYMBOL1(f24);
+
+		CASE(NUM_PLUS):     SYMBOL1(plus);
+		CASE(NUM_MINUS):    SYMBOL1(minus);
+		CASE(NUM_MULTIPLY): SYMBOL1(multiply);
+		CASE(NUM_DIVIDE):   SYMBOL1(divide);
+		CASE(NUM_EQUAL):    SYMBOL1(equal);
+		CASE(NUM_COMMA):    SYMBOL1(comma);
+		CASE(NUM_DECIMAL):  SYMBOL1(decimal);
+		CASE(NUM_CLEAR):    SYMBOL1(clear);
+
+		CASE(CAPSLOCK):   SYMBOL1(capslock);
+		//CASE(NUMLOCK):    SYMBOL1(numlock);
+		//CASE(SCROLLLOCK): SYMBOL1(scrolllock);
+
+		//CASE(PRINTSCREEN): SYMBOL1(printscreen);
+		//CASE(PAUSE):       SYMBOL1(pause);
+		//CASE(BREAK):       SYMBOL2(_break, "break");
+		CASE(SECTION):     SYMBOL1(section);
+		CASE(HELP):        SYMBOL1(help);
+
+		CASE(IME_EISU):       SYMBOL1(eisu);
+		CASE(IME_KANA):       SYMBOL1(kana);
+		//CASE(IME_KANJI):      SYMBOL1(kanji);
+		//CASE(IME_JUNJA):      SYMBOL1(junja);
+		//CASE(IME_PROCESS):    SYMBOL1(process);
+		//CASE(IME_ACCEPT):     SYMBOL1(accept);
+		//CASE(IME_FINAL):      SYMBOL2(_final, "final");
+		//CASE(IME_CONVERT):    SYMBOL1(convert);
+		//CASE(IME_NONCONVERT): SYMBOL1(nonconvert);
+		//CASE(IME_MODECHANGE): SYMBOL1(mode_change);
+
+		CASE(VOLUME_UP):   SYMBOL1(volume_up);
+		CASE(VOLUME_DOWN): SYMBOL1(volume_down);
+		CASE(MUTE):        SYMBOL1(mute);
+
+		//CASE(SLEEP):  SYMBOL1(sleep);
+		//CASE(EXEC):   SYMBOL1(exec);
+		//CASE(PRINT):  SYMBOL1(print);
+		//CASE(APPS):   SYMBOL1(apps);
+		//CASE(SELECT): SYMBOL1(select);
+		//CASE(CLEAR):  SYMBOL1(clear);
+		//CASE(PLAY):   SYMBOL1(play);
+		//CASE(ZOOM):   SYMBOL1(zoom);
+
+		//CASE(BROWSER_BACK):      SYMBOL1(browser_back);
+		//CASE(BROWSER_FORWARD):   SYMBOL1(browser_forward);
+		//CASE(BROWSER_REFRESH):   SYMBOL1(browser_refresh);
+		//CASE(BROWSER_STOP):      SYMBOL1(browser_stop);
+		//CASE(BROWSER_SEARCH):    SYMBOL1(browser_search);
+		//CASE(BROWSER_FAVORITES): SYMBOL1(browser_favorites);
+		//CASE(BROWSER_HOME):      SYMBOL1(browser_home);
+
+		//CASE(MEDIA_NEXT_TRACK): SYMBOL1(media_next);
+		//CASE(MEDIA_PREV_TRACK): SYMBOL1(media_prev);
+		//CASE(MEDIA_STOP):       SYMBOL1(media_stop);
+		//CASE(MEDIA_PLAY_PAUSE): SYMBOL1(media_play_stop);
+
+		//CASE(LAUNCH_MAIL):         SYMBOL1(launch_mail);
+		//CASE(LAUNCH_MEDIA_SELECT): SYMBOL1(launch_media_select);
+		//CASE(LAUNCH_APP1):         SYMBOL1(launch_app1);
+		//CASE(LAUNCH_APP2):         SYMBOL1(launch_app2);
+
+		#undef CASE
+		#undef SYMBOL1
+		#undef SYMBOL2
+	}
+	return nil();
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_chars)
 {
 	CHECK;
 	return value(THIS->chars.c_str());
@@ -59,7 +257,7 @@ RUCY_DEF0(chars)
 RUCY_END
 
 static
-RUCY_DEF0(code)
+RUCY_DEF0(get_code)
 {
 	CHECK;
 	return value(THIS->code);
@@ -67,7 +265,7 @@ RUCY_DEF0(code)
 RUCY_END
 
 static
-RUCY_DEF0(modifiers)
+RUCY_DEF0(get_modifiers)
 {
 	CHECK;
 	return value(THIS->modifiers);
@@ -75,7 +273,7 @@ RUCY_DEF0(modifiers)
 RUCY_END
 
 static
-RUCY_DEF0(repeat)
+RUCY_DEF0(get_repeat)
 {
 	CHECK;
 	return value(THIS->repeat);
@@ -83,10 +281,10 @@ RUCY_DEF0(repeat)
 RUCY_END
 
 static
-RUCY_DEF0(capture)
+RUCY_DEF0(is_captured)
 {
 	CHECK;
-	return value(THIS->capture);
+	return value(THIS->captured);
 }
 RUCY_END
 
@@ -102,12 +300,13 @@ Init_key_event ()
 	cKeyEvent.define_alloc_func(alloc);
 	cKeyEvent.define_private_method("initialize",      initialize);
 	cKeyEvent.define_private_method("initialize_copy", initialize_copy);
-	cKeyEvent.define_method("type", type);
-	cKeyEvent.define_method("chars", chars);
-	cKeyEvent.define_method("code", code);
-	cKeyEvent.define_method("modifiers", modifiers);
-	cKeyEvent.define_method("repeat", repeat);
-	cKeyEvent.define_method("capture?", capture);
+	cKeyEvent.define_method("type",      get_type);
+	cKeyEvent.define_method("key",       get_key);
+	cKeyEvent.define_method("chars",     get_chars);
+	cKeyEvent.define_method("code",      get_code);
+	cKeyEvent.define_method("modifiers", get_modifiers);
+	cKeyEvent.define_method("repeat",    get_repeat);
+	cKeyEvent.define_method("captured?", is_captured);
 	cKeyEvent.define_const("TYPE_NONE", Reflex::KeyEvent::NONE);
 	cKeyEvent.define_const("TYPE_DOWN", Reflex::KeyEvent::DOWN);
 	cKeyEvent.define_const("TYPE_UP",   Reflex::KeyEvent::UP);

data/ext/reflex/native.cpp

@@ -17,6 +17,7 @@ void Init_frame_event ();
 void Init_scroll_event ();
 void Init_focus_event ();
 void Init_key_event ();
+void Init_pointer ();
 void Init_pointer_event ();
 void Init_wheel_event ();
 void Init_capture_event ();
@@ -63,6 +64,7 @@ extern "C" void
 	Init_scroll_event();
 	Init_focus_event();
 	Init_key_event();
+	Init_pointer();
 	Init_pointer_event();
 	Init_wheel_event();
 	Init_capture_event();

data/ext/reflex/pointer.cpp

@@ -0,0 +1,170 @@
+#include "reflex/ruby/pointer.h"
+
+
+#include <rays/ruby/point.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::Pointer)
+
+#define THIS  to<Reflex::Pointer*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::Pointer, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::Pointer>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF8(initialize,
+	id, type, action, position, modifiers, click_count, drag, time)
+{
+	CHECK;
+
+	*THIS = Reflex::Pointer(
+		to<Reflex::Pointer::ID>(id),
+		to<uint>(type),
+		(Reflex::Pointer::Action) to<int>(action),
+		to<Rays::Point>(position),
+		to<uint>(modifiers),
+		to<uint>(click_count),
+		to<bool>(drag),
+		to<double>(time));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Pointer&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_id)
+{
+	CHECK;
+	return value(THIS->id());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_type)
+{
+	CHECK;
+	return value(THIS->type());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_action)
+{
+	CHECK;
+	return value(THIS->action());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_position)
+{
+	CHECK;
+	return value(THIS->position());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_modifiers)
+{
+	CHECK;
+	return value(THIS->modifiers());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_click_count)
+{
+	CHECK;
+	return value(THIS->click_count());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_drag)
+{
+	CHECK;
+	return value(THIS->is_drag());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_time)
+{
+	CHECK;
+	return value(THIS->time());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_prev)
+{
+	CHECK;
+	return value(THIS->prev());
+}
+RUCY_END
+
+
+static Class cPointer;
+
+void
+Init_pointer ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cPointer = mReflex.define_class("Pointer");
+	cPointer.define_alloc_func(alloc);
+	cPointer.define_private_method("initialize",      initialize);
+	cPointer.define_private_method("initialize_copy", initialize_copy);
+	cPointer.define_method("id",                 get_id);
+	cPointer.define_private_method("get_type",   get_type);
+	cPointer.define_private_method("get_action", get_action);
+	cPointer.define_method("position",           get_position);
+	cPointer.define_method("modifiers",          get_modifiers);
+	cPointer.define_method("click_count",        get_click_count);
+	cPointer.define_method("drag?",              is_drag);
+	cPointer.define_method("time",               get_time);
+	cPointer.define_method("prev",               get_prev);
+	cPointer.define_const("TYPE_NONE",    Reflex::Pointer::TYPE_NONE);
+	cPointer.define_const("MOUSE",        Reflex::Pointer::MOUSE);
+	cPointer.define_const("MOUSE_LEFT",   Reflex::Pointer::MOUSE_LEFT);
+	cPointer.define_const("MOUSE_RIGHT",  Reflex::Pointer::MOUSE_RIGHT);
+	cPointer.define_const("MOUSE_MIDDLE", Reflex::Pointer::MOUSE_MIDDLE);
+	cPointer.define_const("TOUCH",        Reflex::Pointer::TOUCH);
+	cPointer.define_const("PEN",          Reflex::Pointer::PEN);
+	cPointer.define_const("ACTION_NONE", Reflex::Pointer::ACTION_NONE);
+	cPointer.define_const("DOWN",        Reflex::Pointer::DOWN);
+	cPointer.define_const("UP",          Reflex::Pointer::UP);
+	cPointer.define_const("MOVE",        Reflex::Pointer::MOVE);
+	cPointer.define_const("CANCEL",      Reflex::Pointer::CANCEL);
+	cPointer.define_const("STAY",        Reflex::Pointer::STAY);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	pointer_class ()
+	{
+		return cPointer;
+	}
+
+
+}// Reflex

data/ext/reflex/pointer_event.cpp

@@ -1,7 +1,9 @@
 #include "reflex/ruby/event.h"
 
 
+#include <vector>
 #include <rays/ruby/point.h>
+#include "reflex/ruby/pointer.h"
 #include "defs.h"
 
 
@@ -20,23 +22,18 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEF6(initialize, type, pointer_type, modifiers, count, drag, positions)
+RUCY_DEFN(initialize)
 {
 	CHECK;
 
-	int size = positions.size();
-	if (size <= 0 || Reflex::PointerEvent::MAX < size)
+	if (argc == 0)
 		argument_error(__FILE__, __LINE__);
 
-	THIS->type         = (Reflex::PointerEvent::Type) to<int>(type);
-	THIS->pointer_type = to<uint>(pointer_type);
-	THIS->modifiers    = to<uint>(modifiers);
-	THIS->count        = to<uint>(count);
-	THIS->drag         = to<bool>(drag);
-	THIS->size         = (size_t) size;
+	std::vector<Reflex::Pointer> pointers;
+	for (size_t i = 0; i < argc; ++i)
+		pointers.emplace_back(to<Reflex::Pointer&>(argv[i]));
 
-	for (int i = 0; i < size; ++i)
-		THIS->positions[i] = to<Rays::Point>(positions[i]);
+	*THIS = Reflex::PointerEvent(&pointers[0], pointers.size());
 
 	return rb_call_super(0, NULL);
 }
@@ -52,98 +49,52 @@ RUCY_DEF1(initialize_copy, obj)
 RUCY_END
 
 static
-RUCY_DEF0(type)
+RUCY_DEF0(get_size)
 {
 	CHECK;
-	return value(THIS->type);
+	return value(THIS->size());
 }
 RUCY_END
 
 static
-RUCY_DEF0(pointer_type)
+RUCY_DEF0(is_empty)
 {
 	CHECK;
-	return value(THIS->pointer_type);
+	return value(THIS->empty());
 }
 RUCY_END
 
 static
-RUCY_DEF0(size)
+RUCY_DEF0(is_captured)
 {
 	CHECK;
-	return value(THIS->size);
+	return value(THIS->is_captured());
 }
 RUCY_END
 
 static
-RUCY_DEF0(modifiers)
-{
-	CHECK;
-	return value(THIS->modifiers);
-}
-RUCY_END
-
-static
-RUCY_DEF0(count)
-{
-	CHECK;
-	return value(THIS->count);
-}
-RUCY_END
-
-static
-RUCY_DEF0(drag)
-{
-	CHECK;
-	return value(THIS->drag);
-}
-RUCY_END
-
-static
-RUCY_DEF0(capture)
-{
-	CHECK;
-	return value(THIS->capture);
-}
-RUCY_END
-
-static
-RUCY_DEF0(x)
-{
-	CHECK;
-	return value(THIS->x);
-}
-RUCY_END
-
-static
-RUCY_DEF0(y)
+RUCY_DEF1(get_at, index)
 {
 	CHECK;
-	return value(THIS->y);
-}
-RUCY_END
 
-static
-RUCY_DEFN(position)
-{
-	CHECK;
-	check_arg_count(__FILE__, __LINE__, "PointerEvent#position", argc, 0, 1);
+	int size = (int) THIS->size();
+	int i    = to<int>(index);
+	if (i < -size || size <= i)
+		return Qnil;
 
-	size_t index = argc >= 1 ? to<int>(argv[0]) : 0;
-	return value(THIS->position(index));
+	return value((*THIS)[i >= 0 ? i : i + size]);
 }
 RUCY_END
 
 static
-RUCY_DEF1(get_at, index)
+RUCY_DEF0(each)
 {
 	CHECK;
 
-	int i = to<int>(index);
-	if (i < 0 || THIS->size <= (size_t) i)
-		index_error(__FILE__, __LINE__);
-
-	return value((*THIS)[i]);
+	Value ret;
+	for (size_t i = 0, size = THIS->size(); i < size; ++i)
+		ret = rb_yield(value((*THIS)[i]));
+	return ret;
 }
 RUCY_END
 
@@ -159,27 +110,11 @@ Init_pointer_event ()
 	cPointerEvent.define_alloc_func(alloc);
 	cPointerEvent.define_private_method("initialize",      initialize);
 	cPointerEvent.define_private_method("initialize_copy", initialize_copy);
-	cPointerEvent.define_method("type", type);
-	cPointerEvent.define_method("pointer_type", pointer_type);
-	cPointerEvent.define_method("size", size);
-	cPointerEvent.define_method("modifiers", modifiers);
-	cPointerEvent.define_method("count", count);
-	cPointerEvent.define_method("drag?", drag);
-	cPointerEvent.define_method("capture?", capture);
-	cPointerEvent.define_method("x", x);
-	cPointerEvent.define_method("y", y);
-	cPointerEvent.define_method("position", position);
-	cPointerEvent.define_method("[]", get_at);
-	cPointerEvent.define_const("TYPE_NONE", Reflex::PointerEvent::NONE);
-	cPointerEvent.define_const("TYPE_DOWN", Reflex::PointerEvent::DOWN);
-	cPointerEvent.define_const("TYPE_UP",   Reflex::PointerEvent::UP);
-	cPointerEvent.define_const("TYPE_MOVE", Reflex::PointerEvent::MOVE);
-	cPointerEvent.define_const("POINTER_NONE",         Reflex::POINTER_NONE);
-	cPointerEvent.define_const("POINTER_MOUSE_LEFT",   Reflex::POINTER_MOUSE_LEFT);
-	cPointerEvent.define_const("POINTER_MOUSE_RIGHT",  Reflex::POINTER_MOUSE_RIGHT);
-	cPointerEvent.define_const("POINTER_MOUSE_MIDDLE", Reflex::POINTER_MOUSE_MIDDLE);
-	cPointerEvent.define_const("POINTER_TOUCH",        Reflex::POINTER_TOUCH);
-	cPointerEvent.define_const("POINTER_PEN",          Reflex::POINTER_PEN);
+	cPointerEvent.define_method("size",      get_size);
+	cPointerEvent.define_method("empty?",    is_empty);
+	cPointerEvent.define_method("captured?", is_captured);
+	cPointerEvent.define_method("[]",        get_at);
+	cPointerEvent.define_method("each",      each);
 }
 
 

data/ext/reflex/selector.cpp

@@ -90,6 +90,14 @@ RUCY_DEF0(each_tag)
 }
 RUCY_END
 
+static
+RUCY_DEF0(is_empty)
+{
+	CHECK;
+	return value(C_THIS->empty());
+}
+RUCY_END
+
 static
 RUCY_DEF1(contains, selector)
 {
@@ -124,6 +132,7 @@ Init_selector ()
 	cSelector.define_method("clear_tags", clear_tags);
 	cSelector.define_method("tag?",       has_tag);
 	cSelector.define_method("each_tag",   each_tag);
+	cSelector.define_method("empty?",     is_empty);
 	cSelector.define_method("contains", contains);
 	cSelector.define_method("==", equal);
 }