src/scripting/smjs/keybinding.c

   1 /* "elinks.keymaps" */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include "elinks.h"
   8
   9 #include "config/kbdbind.h"
  10 #include "ecmascript/spidermonkey/util.h"
  11 #include "main/event.h"
  12 #include "scripting/smjs/core.h"
  13 #include "scripting/smjs/elinks_object.h"
  14 #include "util/memory.h"
  15
  16 static const JSClass keymap_class; /* defined below */
  17
  18 /* @keymap_class.getProperty */
  19 static JSBool
  20 keymap_get_property(JSContext *ctx, JSObject *obj, jsval id, jsval *vp)
  21 {
  22         unsigned char *action_str;
  23         const unsigned char *keystroke_str;
  24         int *data;
  25
  26         /* This can be called if @obj if not itself an instance of the
  27          * appropriate class but has one in its prototype chain.  Fail
  28          * such calls.  */
  29         if (!JS_InstanceOf(ctx, obj, (JSClass *) &keymap_class, NULL))
  30                 return JS_FALSE;
  31
  32         data = JS_GetInstancePrivate(ctx, obj,
  33                                      (JSClass *) &keymap_class, NULL);
  34
  35         keystroke_str = JS_GetStringBytes(JS_ValueToString(ctx, id));
  36         if (!keystroke_str) goto ret_null;
  37
  38         action_str = get_action_name_from_keystroke((enum keymap_id) *data,
  39                                                     keystroke_str);
  40         if (!action_str) goto ret_null;
  41
  42         *vp = STRING_TO_JSVAL(JS_NewStringCopyZ(ctx, action_str));
  43
  44         return JS_TRUE;
  45
  46 ret_null:
  47         *vp = JSVAL_NULL;
  48
  49         return JS_TRUE;
  50 }
  51
  52 static enum evhook_status
  53 smjs_keybinding_action_callback(va_list ap, void *data)
  54 {
  55         jsval rval;
  56         struct session *ses = va_arg(ap, struct session *);
  57         JSObject *jsobj = data;
  58         JSFunction *func = JS_ValueToFunction(smjs_ctx, OBJECT_TO_JSVAL(jsobj));
  59
  60         evhook_use_params(ses);
  61
  62         assert(func);
  63
  64         smjs_ses = ses;
  65
  66         JS_CallFunction(smjs_ctx, NULL, func, 0, NULL, &rval);
  67
  68         smjs_ses = NULL;
  69
  70         return EVENT_HOOK_STATUS_LAST;
  71 }
  72
  73 /* @keymap_class.setProperty */
  74 static JSBool
  75 keymap_set_property(JSContext *ctx, JSObject *obj, jsval id, jsval *vp)
  76 {
  77         int *data;
  78         unsigned char *keymap_str;
  79         const unsigned char *keystroke_str;
  80
  81         /* This can be called if @obj if not itself an instance of the
  82          * appropriate class but has one in its prototype chain.  Fail
  83          * such calls.  */
  84         if (!JS_InstanceOf(ctx, obj, (JSClass *) &keymap_class, NULL))
  85                 return JS_FALSE;
  86
  87         data = JS_GetInstancePrivate(ctx, obj,
  88                                      (JSClass *) &keymap_class, NULL);
  89
  90         /* Ugly fact: we need to get the string from the id to give to bind_do,
  91          * which will of course then convert the string back to an id... */
  92         keymap_str = get_keymap_name((enum keymap_id) *data);
  93         if (!keymap_str) return JS_FALSE;
  94
  95         keystroke_str = JS_GetStringBytes(JS_ValueToString(ctx, id));
  96         if (!keystroke_str) return JS_FALSE;
  97
  98         if (JSVAL_IS_STRING(*vp)) {
  99                 unsigned char *action_str;
 100
 101                 action_str = JS_GetStringBytes(JS_ValueToString(ctx, *vp));
 102                 if (!action_str) return JS_FALSE;
 103
 104                 if (bind_do(keymap_str, keystroke_str, action_str, 0))
 105                         return JS_FALSE;
 106
 107                 return JS_TRUE;
 108
 109         } else if (JSVAL_IS_OBJECT(*vp)) {
 110                 unsigned char *err = NULL;
 111                 int event_id;
 112                 struct string event_name = NULL_STRING;
 113                 JSObject *jsobj = JSVAL_TO_OBJECT(*vp);
 114
 115                 if (JS_FALSE == JS_ObjectIsFunction(ctx, jsobj))
 116                         return JS_FALSE;
 117
 118                 if (!init_string(&event_name)) return JS_FALSE;
 119
 120                 add_format_to_string(&event_name, "smjs-run-func %p", jsobj);
 121
 122                 event_id = bind_key_to_event_name(keymap_str,
 123                                                   keystroke_str,
 124                                                   event_name.source, &err);
 125
 126                 done_string(&event_name);
 127
 128                 if (err) {
 129                         alert_smjs_error(err);
 130
 131                         return JS_FALSE;
 132                 }
 133
 134                 event_id = register_event_hook(event_id,
 135                                                smjs_keybinding_action_callback,
 136                                                0, (void *) jsobj);
 137
 138                 if (event_id == EVENT_NONE) {
 139                         alert_smjs_error("error registering event hook"
 140                                          " for keybinding");
 141
 142                         return JS_FALSE;
 143                 }
 144
 145                 return JS_TRUE;
 146         }
 147
 148         return JS_FALSE;
 149 }
 150
 151 /* @keymap_class.finalize */
 152 static void
 153 keymap_finalize(JSContext *ctx, JSObject *obj)
 154 {
 155         void *data;
 156
 157         assert(JS_InstanceOf(ctx, obj, (JSClass *) &keymap_class, NULL));
 158         if_assert_failed return;
 159
 160         data = JS_GetInstancePrivate(ctx, obj,
 161                                      (JSClass *) &keymap_class, NULL);
 162
 163         mem_free(data);
 164 }
 165
 166 static const JSClass keymap_class = {
 167         "keymap",
 168         JSCLASS_HAS_PRIVATE,    /* int * */
 169         JS_PropertyStub, JS_PropertyStub,
 170         keymap_get_property, keymap_set_property,
 171         JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, keymap_finalize,
 172 };
 173
 174 static JSObject *
 175 smjs_get_keymap_object(enum keymap_id keymap_id)
 176 {
 177         int *data;
 178         JSObject *keymap_object;
 179
 180         assert(smjs_ctx);
 181
 182         keymap_object = JS_NewObject(smjs_ctx, (JSClass *) &keymap_class,
 183                                      NULL, NULL);
 184
 185         if (!keymap_object) return NULL;
 186
 187         data = intdup(keymap_id);
 188         if (!data) return NULL;
 189
 190         if (JS_TRUE == JS_SetPrivate(smjs_ctx, keymap_object, data)) /* to @keymap_class */
 191                 return keymap_object;
 192
 193         mem_free(data);
 194
 195         return NULL;
 196 }
 197
 198 static const JSClass keymaps_hash_class = {
 199         "keymaps_hash",
 200         JSCLASS_HAS_PRIVATE,
 201         JS_PropertyStub, JS_PropertyStub,
 202         JS_PropertyStub, JS_PropertyStub,
 203         JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub,
 204 };
 205
 206 static JSObject *
 207 smjs_get_keymap_hash_object(void)
 208 {
 209         jsval val;
 210         enum keymap_id keymap_id;
 211         JSObject *keymaps_hash;
 212
 213         keymaps_hash = JS_NewObject(smjs_ctx, (JSClass *) &keymaps_hash_class,
 214                                     NULL, NULL);
 215         if (!keymaps_hash) return NULL;
 216
 217         for (keymap_id = 0; keymap_id < KEYMAP_MAX; ++keymap_id) {
 218                 unsigned char *keymap_str = get_keymap_name(keymap_id);
 219                 JSObject *map = smjs_get_keymap_object(keymap_id);
 220
 221                 assert(keymap_str);
 222
 223                 if (!map) return NULL;
 224
 225                 val = OBJECT_TO_JSVAL(map);
 226
 227                 JS_SetProperty(smjs_ctx, keymaps_hash, keymap_str, &val);
 228         }
 229
 230         return keymaps_hash;
 231 }
 232
 233 void
 234 smjs_init_keybinding_interface(void)
 235 {
 236         jsval val;
 237         struct JSObject *keymaps_hash;
 238
 239         if (!smjs_ctx || !smjs_elinks_object)
 240                 return;
 241
 242         keymaps_hash = smjs_get_keymap_hash_object();
 243         if (!keymaps_hash) return;
 244
 245         val = OBJECT_TO_JSVAL(keymaps_hash);
 246
 247         JS_SetProperty(smjs_ctx, smjs_elinks_object, "keymaps", &val);
 248 }