reflexion 0.1.21 → 0.1.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a92694d805e53936c602a5b7b4f686c39505f90683f039d021678dae013408a
-  data.tar.gz: 78b1cc8751399d48133827f757bd53dd8b165afb695da6b233d80134977274ba
+  metadata.gz: 3ddbc019fc036a931bdef9ec81872663f375a2e440003ef18b638666e61f7ed7
+  data.tar.gz: 6a803b54ac97bbe773c432f2089383983b95e2f5187891e5fd79aaca375fa9d4
 SHA512:
-  metadata.gz: e0086b7bcbc0f684dc3e94fe57fee7057e055708f338d22c11f6dea11dd9c36056079c2558c77bb24d8277b15758e86707a95c0c03ae9e21c35e8192385efe1f
-  data.tar.gz: 656414624e17e036e032b0904a7499c6fbb3846b96b8eac83bdf6c6ec6154e89fc93f73ca5d95ee340336830579546cc179342374a7624b8870af4c192ff97d4
+  metadata.gz: de9b87fd54230c33385b5e252ea39aae91b395e6f9aa2d2ef5b8dfcb9aead804831c7b6f8614b296df041914cf0a69e998e41e518d955d644ccec3e225a21c9d
+  data.tar.gz: c2072f7e2fa3c76e3d4a6aece31a6fa9c90f838bb7d96c2cc636def5c375b1c90f702634558363e0f282c0c79fc6adecd0484baa85c1d2c6c29a43e52118caad

data/.doc/ext/reflex/contact_event.cpp

@@ -39,21 +39,21 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE type(VALUE self)
+VALUE get_type(VALUE self)
 {
 	CHECK;
 	return value(THIS->type);
 }
 
 static
-VALUE shape(VALUE self)
+VALUE get_shape(VALUE self)
 {
 	CHECK;
 	return value(THIS->shape);
 }
 
 static
-VALUE view(VALUE self)
+VALUE get_view(VALUE self)
 {
 	CHECK;
 	return value(THIS->view);
@@ -71,9 +71,9 @@ Init_contact_event ()
 	rb_define_alloc_func(cContactEvent, alloc);
 	rb_define_private_method(cContactEvent, "initialize", RUBY_METHOD_FUNC(initialize), 2);
 	rb_define_private_method(cContactEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cContactEvent, "type", RUBY_METHOD_FUNC(type), 0);
-	rb_define_method(cContactEvent, "shape", RUBY_METHOD_FUNC(shape), 0);
-	rb_define_method(cContactEvent, "view", RUBY_METHOD_FUNC(view), 0);
+	rb_define_method(cContactEvent, "type", RUBY_METHOD_FUNC(get_type), 0);
+	rb_define_method(cContactEvent, "shape", RUBY_METHOD_FUNC(get_shape), 0);
+	rb_define_method(cContactEvent, "view", RUBY_METHOD_FUNC(get_view), 0);
 	cContactEvent.define_const("TYPE_NONE",  Reflex::ContactEvent::NONE);
 	cContactEvent.define_const("TYPE_BEGIN", Reflex::ContactEvent::BEGIN);
 	cContactEvent.define_const("TYPE_END",   Reflex::ContactEvent::END);

data/.doc/ext/reflex/focus_event.cpp

@@ -39,21 +39,21 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE type(VALUE self)
+VALUE get_type(VALUE self)
 {
 	CHECK;
 	return value(THIS->type);
 }
 
 static
-VALUE current(VALUE self)
+VALUE get_current(VALUE self)
 {
 	CHECK;
 	return THIS->current ? value(THIS->current) : nil();
 }
 
 static
-VALUE last(VALUE self)
+VALUE get_last(VALUE self)
 {
 	CHECK;
 	return THIS->last ? value(THIS->last) : nil();
@@ -71,9 +71,9 @@ Init_focus_event ()
 	rb_define_alloc_func(cFocusEvent, alloc);
 	rb_define_private_method(cFocusEvent, "initialize", RUBY_METHOD_FUNC(initialize), 3);
 	rb_define_private_method(cFocusEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cFocusEvent, "type", RUBY_METHOD_FUNC(type), 0);
-	rb_define_method(cFocusEvent, "current", RUBY_METHOD_FUNC(current), 0);
-	rb_define_method(cFocusEvent, "last", RUBY_METHOD_FUNC(last), 0);
+	rb_define_method(cFocusEvent, "type", RUBY_METHOD_FUNC(get_type), 0);
+	rb_define_method(cFocusEvent, "current", RUBY_METHOD_FUNC(get_current), 0);
+	rb_define_method(cFocusEvent, "last", RUBY_METHOD_FUNC(get_last), 0);
 	cFocusEvent.define_const("TYPE_NONE",  Reflex::FocusEvent::NONE);
 	cFocusEvent.define_const("TYPE_FOCUS", Reflex::FocusEvent::FOCUS);
 	cFocusEvent.define_const("TYPE_BLUR",  Reflex::FocusEvent::BLUR);

data/.doc/ext/reflex/key_event.cpp

@@ -40,42 +40,239 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE type(VALUE self)
+VALUE get_type(VALUE self)
 {
 	CHECK;
 	return value(THIS->type);
 }
 
 static
-VALUE chars(VALUE self)
+VALUE get_key(VALUE self)
+{
+	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();
+}
+
+static
+VALUE get_chars(VALUE self)
 {
 	CHECK;
 	return value(THIS->chars.c_str());
 }
 
 static
-VALUE code(VALUE self)
+VALUE get_code(VALUE self)
 {
 	CHECK;
 	return value(THIS->code);
 }
 
 static
-VALUE modifiers(VALUE self)
+VALUE get_modifiers(VALUE self)
 {
 	CHECK;
 	return value(THIS->modifiers);
 }
 
 static
-VALUE repeat(VALUE self)
+VALUE get_repeat(VALUE self)
 {
 	CHECK;
 	return value(THIS->repeat);
 }
 
 static
-VALUE capture(VALUE self)
+VALUE is_capture(VALUE self)
 {
 	CHECK;
 	return value(THIS->capture);
@@ -93,12 +290,13 @@ Init_key_event ()
 	rb_define_alloc_func(cKeyEvent, alloc);
 	rb_define_private_method(cKeyEvent, "initialize", RUBY_METHOD_FUNC(initialize), 5);
 	rb_define_private_method(cKeyEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cKeyEvent, "type", RUBY_METHOD_FUNC(type), 0);
-	rb_define_method(cKeyEvent, "chars", RUBY_METHOD_FUNC(chars), 0);
-	rb_define_method(cKeyEvent, "code", RUBY_METHOD_FUNC(code), 0);
-	rb_define_method(cKeyEvent, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
-	rb_define_method(cKeyEvent, "repeat", RUBY_METHOD_FUNC(repeat), 0);
-	cKeyEvent.define_method("capture?", capture);
+	rb_define_method(cKeyEvent, "type", RUBY_METHOD_FUNC(get_type), 0);
+	rb_define_method(cKeyEvent, "key", RUBY_METHOD_FUNC(get_key), 0);
+	rb_define_method(cKeyEvent, "chars", RUBY_METHOD_FUNC(get_chars), 0);
+	rb_define_method(cKeyEvent, "code", RUBY_METHOD_FUNC(get_code), 0);
+	rb_define_method(cKeyEvent, "modifiers", RUBY_METHOD_FUNC(get_modifiers), 0);
+	rb_define_method(cKeyEvent, "repeat", RUBY_METHOD_FUNC(get_repeat), 0);
+	cKeyEvent.define_method("capture?",  is_capture);
 	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/.doc/ext/reflex/pointer_event.cpp

@@ -49,70 +49,70 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE type(VALUE self)
+VALUE get_type(VALUE self)
 {
 	CHECK;
 	return value(THIS->type);
 }
 
 static
-VALUE pointer_type(VALUE self)
+VALUE get_pointer_type(VALUE self)
 {
 	CHECK;
 	return value(THIS->pointer_type);
 }
 
 static
-VALUE size(VALUE self)
+VALUE get_size(VALUE self)
 {
 	CHECK;
 	return value(THIS->size);
 }
 
 static
-VALUE modifiers(VALUE self)
+VALUE get_modifiers(VALUE self)
 {
 	CHECK;
 	return value(THIS->modifiers);
 }
 
 static
-VALUE count(VALUE self)
+VALUE get_count(VALUE self)
 {
 	CHECK;
 	return value(THIS->count);
 }
 
 static
-VALUE drag(VALUE self)
+VALUE is_drag(VALUE self)
 {
 	CHECK;
 	return value(THIS->drag);
 }
 
 static
-VALUE capture(VALUE self)
+VALUE is_capture(VALUE self)
 {
 	CHECK;
 	return value(THIS->capture);
 }
 
 static
-VALUE x(VALUE self)
+VALUE get_x(VALUE self)
 {
 	CHECK;
 	return value(THIS->x);
 }
 
 static
-VALUE y(VALUE self)
+VALUE get_y(VALUE self)
 {
 	CHECK;
 	return value(THIS->y);
 }
 
 static
-VALUE position(VALUE self)
+VALUE get_position(VALUE self)
 {
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "PointerEvent#position", argc, 0, 1);
@@ -145,17 +145,17 @@ Init_pointer_event ()
 	rb_define_alloc_func(cPointerEvent, alloc);
 	rb_define_private_method(cPointerEvent, "initialize", RUBY_METHOD_FUNC(initialize), 6);
 	rb_define_private_method(cPointerEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cPointerEvent, "type", RUBY_METHOD_FUNC(type), 0);
-	rb_define_method(cPointerEvent, "pointer_type", RUBY_METHOD_FUNC(pointer_type), 0);
-	rb_define_method(cPointerEvent, "size", RUBY_METHOD_FUNC(size), 0);
-	rb_define_method(cPointerEvent, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
-	rb_define_method(cPointerEvent, "count", RUBY_METHOD_FUNC(count), 0);
-	cPointerEvent.define_method("drag?", drag);
-	cPointerEvent.define_method("capture?", capture);
-	rb_define_method(cPointerEvent, "x", RUBY_METHOD_FUNC(x), 0);
-	rb_define_method(cPointerEvent, "y", RUBY_METHOD_FUNC(y), 0);
-	rb_define_method(cPointerEvent, "position", RUBY_METHOD_FUNC(position), -1);
-	cPointerEvent.define_method("[]", get_at);
+	rb_define_method(cPointerEvent, "type", RUBY_METHOD_FUNC(get_type), 0);
+	rb_define_method(cPointerEvent, "pointer_type", RUBY_METHOD_FUNC(get_pointer_type), 0);
+	rb_define_method(cPointerEvent, "size", RUBY_METHOD_FUNC(get_size), 0);
+	rb_define_method(cPointerEvent, "modifiers", RUBY_METHOD_FUNC(get_modifiers), 0);
+	rb_define_method(cPointerEvent, "count", RUBY_METHOD_FUNC(get_count), 0);
+	cPointerEvent.define_method("drag?",        is_drag);
+	cPointerEvent.define_method("capture?",     is_capture);
+	rb_define_method(cPointerEvent, "x", RUBY_METHOD_FUNC(get_x), 0);
+	rb_define_method(cPointerEvent, "y", RUBY_METHOD_FUNC(get_y), 0);
+	rb_define_method(cPointerEvent, "position", RUBY_METHOD_FUNC(get_position), -1);
+	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);