github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/input/ime/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/input/ime", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "constof_AssistiveWindowButton": (ref: heap.Ref<string>): number => { 8 const idx = ["undo", "addToDictionary"].indexOf(A.H.get(ref)); 9 return idx < 0 ? 0 : idx + 1; 10 }, 11 "constof_AssistiveWindowType": (ref: heap.Ref<string>): number => { 12 const idx = ["undo"].indexOf(A.H.get(ref)); 13 return idx < 0 ? 0 : idx + 1; 14 }, 15 16 "store_AssistiveWindowProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 17 const x = A.H.get<any>(ref); 18 19 if (typeof x === "undefined") { 20 A.store.Bool(ptr + 9, false); 21 A.store.Ref(ptr + 0, undefined); 22 A.store.Enum(ptr + 4, -1); 23 A.store.Bool(ptr + 8, false); 24 } else { 25 A.store.Bool(ptr + 9, true); 26 A.store.Ref(ptr + 0, x["announceString"]); 27 A.store.Enum(ptr + 4, ["undo"].indexOf(x["type"] as string)); 28 A.store.Bool(ptr + 8, x["visible"] ? true : false); 29 } 30 }, 31 "load_AssistiveWindowProperties": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 32 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 33 34 x["announceString"] = A.load.Ref(ptr + 0, undefined); 35 x["type"] = A.load.Enum(ptr + 4, ["undo"]); 36 x["visible"] = A.load.Bool(ptr + 8); 37 return create === A.H.TRUE ? A.H.push(x) : ref; 38 }, 39 "constof_AutoCapitalizeType": (ref: heap.Ref<string>): number => { 40 const idx = ["characters", "words", "sentences"].indexOf(A.H.get(ref)); 41 return idx < 0 ? 0 : idx + 1; 42 }, 43 44 "store_ClearCompositionArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 45 const x = A.H.get<any>(ref); 46 47 if (typeof x === "undefined") { 48 A.store.Bool(ptr + 8, false); 49 A.store.Int64(ptr + 0, 0); 50 } else { 51 A.store.Bool(ptr + 8, true); 52 A.store.Int64(ptr + 0, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 53 } 54 }, 55 "load_ClearCompositionArgParameters": ( 56 ptr: Pointer, 57 create: heap.Ref<boolean>, 58 ref: heap.Ref<any> 59 ): heap.Ref<any> => { 60 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 61 62 x["contextID"] = A.load.Int64(ptr + 0); 63 return create === A.H.TRUE ? A.H.push(x) : ref; 64 }, 65 66 "store_CommitTextArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 67 const x = A.H.get<any>(ref); 68 69 if (typeof x === "undefined") { 70 A.store.Bool(ptr + 12, false); 71 A.store.Int64(ptr + 0, 0); 72 A.store.Ref(ptr + 8, undefined); 73 } else { 74 A.store.Bool(ptr + 12, true); 75 A.store.Int64(ptr + 0, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 76 A.store.Ref(ptr + 8, x["text"]); 77 } 78 }, 79 "load_CommitTextArgParameters": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 80 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 81 82 x["contextID"] = A.load.Int64(ptr + 0); 83 x["text"] = A.load.Ref(ptr + 8, undefined); 84 return create === A.H.TRUE ? A.H.push(x) : ref; 85 }, 86 87 "store_DeleteSurroundingTextArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 88 const x = A.H.get<any>(ref); 89 90 if (typeof x === "undefined") { 91 A.store.Bool(ptr + 32, false); 92 A.store.Int64(ptr + 0, 0); 93 A.store.Ref(ptr + 8, undefined); 94 A.store.Int64(ptr + 16, 0); 95 A.store.Int64(ptr + 24, 0); 96 } else { 97 A.store.Bool(ptr + 32, true); 98 A.store.Int64(ptr + 0, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 99 A.store.Ref(ptr + 8, x["engineID"]); 100 A.store.Int64(ptr + 16, x["length"] === undefined ? 0 : (x["length"] as number)); 101 A.store.Int64(ptr + 24, x["offset"] === undefined ? 0 : (x["offset"] as number)); 102 } 103 }, 104 "load_DeleteSurroundingTextArgParameters": ( 105 ptr: Pointer, 106 create: heap.Ref<boolean>, 107 ref: heap.Ref<any> 108 ): heap.Ref<any> => { 109 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 110 111 x["contextID"] = A.load.Int64(ptr + 0); 112 x["engineID"] = A.load.Ref(ptr + 8, undefined); 113 x["length"] = A.load.Int64(ptr + 16); 114 x["offset"] = A.load.Int64(ptr + 24); 115 return create === A.H.TRUE ? A.H.push(x) : ref; 116 }, 117 "constof_InputContextType": (ref: heap.Ref<string>): number => { 118 const idx = ["text", "search", "tel", "url", "email", "number", "password", "null"].indexOf(A.H.get(ref)); 119 return idx < 0 ? 0 : idx + 1; 120 }, 121 122 "store_InputContext": (ptr: Pointer, ref: heap.Ref<any>) => { 123 const x = A.H.get<any>(ref); 124 125 if (typeof x === "undefined") { 126 A.store.Bool(ptr + 24, false); 127 A.store.Enum(ptr + 0, -1); 128 A.store.Bool(ptr + 4, false); 129 A.store.Bool(ptr + 5, false); 130 A.store.Int64(ptr + 8, 0); 131 A.store.Bool(ptr + 16, false); 132 A.store.Bool(ptr + 17, false); 133 A.store.Enum(ptr + 20, -1); 134 } else { 135 A.store.Bool(ptr + 24, true); 136 A.store.Enum(ptr + 0, ["characters", "words", "sentences"].indexOf(x["autoCapitalize"] as string)); 137 A.store.Bool(ptr + 4, x["autoComplete"] ? true : false); 138 A.store.Bool(ptr + 5, x["autoCorrect"] ? true : false); 139 A.store.Int64(ptr + 8, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 140 A.store.Bool(ptr + 16, x["shouldDoLearning"] ? true : false); 141 A.store.Bool(ptr + 17, x["spellCheck"] ? true : false); 142 A.store.Enum( 143 ptr + 20, 144 ["text", "search", "tel", "url", "email", "number", "password", "null"].indexOf(x["type"] as string) 145 ); 146 } 147 }, 148 "load_InputContext": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 149 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 150 151 x["autoCapitalize"] = A.load.Enum(ptr + 0, ["characters", "words", "sentences"]); 152 x["autoComplete"] = A.load.Bool(ptr + 4); 153 x["autoCorrect"] = A.load.Bool(ptr + 5); 154 x["contextID"] = A.load.Int64(ptr + 8); 155 x["shouldDoLearning"] = A.load.Bool(ptr + 16); 156 x["spellCheck"] = A.load.Bool(ptr + 17); 157 x["type"] = A.load.Enum(ptr + 20, ["text", "search", "tel", "url", "email", "number", "password", "null"]); 158 return create === A.H.TRUE ? A.H.push(x) : ref; 159 }, 160 "constof_KeyboardEventType": (ref: heap.Ref<string>): number => { 161 const idx = ["keyup", "keydown"].indexOf(A.H.get(ref)); 162 return idx < 0 ? 0 : idx + 1; 163 }, 164 165 "store_KeyboardEvent": (ptr: Pointer, ref: heap.Ref<any>) => { 166 const x = A.H.get<any>(ref); 167 168 if (typeof x === "undefined") { 169 A.store.Bool(ptr + 50, false); 170 A.store.Bool(ptr + 44, false); 171 A.store.Bool(ptr + 0, false); 172 A.store.Bool(ptr + 45, false); 173 A.store.Bool(ptr + 1, false); 174 A.store.Bool(ptr + 46, false); 175 A.store.Bool(ptr + 2, false); 176 A.store.Ref(ptr + 4, undefined); 177 A.store.Bool(ptr + 47, false); 178 A.store.Bool(ptr + 8, false); 179 A.store.Ref(ptr + 12, undefined); 180 A.store.Ref(ptr + 16, undefined); 181 A.store.Bool(ptr + 48, false); 182 A.store.Int64(ptr + 24, 0); 183 A.store.Ref(ptr + 32, undefined); 184 A.store.Bool(ptr + 49, false); 185 A.store.Bool(ptr + 36, false); 186 A.store.Enum(ptr + 40, -1); 187 } else { 188 A.store.Bool(ptr + 50, true); 189 A.store.Bool(ptr + 44, "altKey" in x ? true : false); 190 A.store.Bool(ptr + 0, x["altKey"] ? true : false); 191 A.store.Bool(ptr + 45, "altgrKey" in x ? true : false); 192 A.store.Bool(ptr + 1, x["altgrKey"] ? true : false); 193 A.store.Bool(ptr + 46, "capsLock" in x ? true : false); 194 A.store.Bool(ptr + 2, x["capsLock"] ? true : false); 195 A.store.Ref(ptr + 4, x["code"]); 196 A.store.Bool(ptr + 47, "ctrlKey" in x ? true : false); 197 A.store.Bool(ptr + 8, x["ctrlKey"] ? true : false); 198 A.store.Ref(ptr + 12, x["extensionId"]); 199 A.store.Ref(ptr + 16, x["key"]); 200 A.store.Bool(ptr + 48, "keyCode" in x ? true : false); 201 A.store.Int64(ptr + 24, x["keyCode"] === undefined ? 0 : (x["keyCode"] as number)); 202 A.store.Ref(ptr + 32, x["requestId"]); 203 A.store.Bool(ptr + 49, "shiftKey" in x ? true : false); 204 A.store.Bool(ptr + 36, x["shiftKey"] ? true : false); 205 A.store.Enum(ptr + 40, ["keyup", "keydown"].indexOf(x["type"] as string)); 206 } 207 }, 208 "load_KeyboardEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 209 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 210 211 if (A.load.Bool(ptr + 44)) { 212 x["altKey"] = A.load.Bool(ptr + 0); 213 } else { 214 delete x["altKey"]; 215 } 216 if (A.load.Bool(ptr + 45)) { 217 x["altgrKey"] = A.load.Bool(ptr + 1); 218 } else { 219 delete x["altgrKey"]; 220 } 221 if (A.load.Bool(ptr + 46)) { 222 x["capsLock"] = A.load.Bool(ptr + 2); 223 } else { 224 delete x["capsLock"]; 225 } 226 x["code"] = A.load.Ref(ptr + 4, undefined); 227 if (A.load.Bool(ptr + 47)) { 228 x["ctrlKey"] = A.load.Bool(ptr + 8); 229 } else { 230 delete x["ctrlKey"]; 231 } 232 x["extensionId"] = A.load.Ref(ptr + 12, undefined); 233 x["key"] = A.load.Ref(ptr + 16, undefined); 234 if (A.load.Bool(ptr + 48)) { 235 x["keyCode"] = A.load.Int64(ptr + 24); 236 } else { 237 delete x["keyCode"]; 238 } 239 x["requestId"] = A.load.Ref(ptr + 32, undefined); 240 if (A.load.Bool(ptr + 49)) { 241 x["shiftKey"] = A.load.Bool(ptr + 36); 242 } else { 243 delete x["shiftKey"]; 244 } 245 x["type"] = A.load.Enum(ptr + 40, ["keyup", "keydown"]); 246 return create === A.H.TRUE ? A.H.push(x) : ref; 247 }, 248 "constof_MenuItemStyle": (ref: heap.Ref<string>): number => { 249 const idx = ["check", "radio", "separator"].indexOf(A.H.get(ref)); 250 return idx < 0 ? 0 : idx + 1; 251 }, 252 253 "store_MenuItem": (ptr: Pointer, ref: heap.Ref<any>) => { 254 const x = A.H.get<any>(ref); 255 256 if (typeof x === "undefined") { 257 A.store.Bool(ptr + 20, false); 258 A.store.Bool(ptr + 17, false); 259 A.store.Bool(ptr + 0, false); 260 A.store.Bool(ptr + 18, false); 261 A.store.Bool(ptr + 1, false); 262 A.store.Ref(ptr + 4, undefined); 263 A.store.Ref(ptr + 8, undefined); 264 A.store.Enum(ptr + 12, -1); 265 A.store.Bool(ptr + 19, false); 266 A.store.Bool(ptr + 16, false); 267 } else { 268 A.store.Bool(ptr + 20, true); 269 A.store.Bool(ptr + 17, "checked" in x ? true : false); 270 A.store.Bool(ptr + 0, x["checked"] ? true : false); 271 A.store.Bool(ptr + 18, "enabled" in x ? true : false); 272 A.store.Bool(ptr + 1, x["enabled"] ? true : false); 273 A.store.Ref(ptr + 4, x["id"]); 274 A.store.Ref(ptr + 8, x["label"]); 275 A.store.Enum(ptr + 12, ["check", "radio", "separator"].indexOf(x["style"] as string)); 276 A.store.Bool(ptr + 19, "visible" in x ? true : false); 277 A.store.Bool(ptr + 16, x["visible"] ? true : false); 278 } 279 }, 280 "load_MenuItem": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 281 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 282 283 if (A.load.Bool(ptr + 17)) { 284 x["checked"] = A.load.Bool(ptr + 0); 285 } else { 286 delete x["checked"]; 287 } 288 if (A.load.Bool(ptr + 18)) { 289 x["enabled"] = A.load.Bool(ptr + 1); 290 } else { 291 delete x["enabled"]; 292 } 293 x["id"] = A.load.Ref(ptr + 4, undefined); 294 x["label"] = A.load.Ref(ptr + 8, undefined); 295 x["style"] = A.load.Enum(ptr + 12, ["check", "radio", "separator"]); 296 if (A.load.Bool(ptr + 19)) { 297 x["visible"] = A.load.Bool(ptr + 16); 298 } else { 299 delete x["visible"]; 300 } 301 return create === A.H.TRUE ? A.H.push(x) : ref; 302 }, 303 304 "store_MenuParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 305 const x = A.H.get<any>(ref); 306 307 if (typeof x === "undefined") { 308 A.store.Bool(ptr + 8, false); 309 A.store.Ref(ptr + 0, undefined); 310 A.store.Ref(ptr + 4, undefined); 311 } else { 312 A.store.Bool(ptr + 8, true); 313 A.store.Ref(ptr + 0, x["engineID"]); 314 A.store.Ref(ptr + 4, x["items"]); 315 } 316 }, 317 "load_MenuParameters": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 318 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 319 320 x["engineID"] = A.load.Ref(ptr + 0, undefined); 321 x["items"] = A.load.Ref(ptr + 4, undefined); 322 return create === A.H.TRUE ? A.H.push(x) : ref; 323 }, 324 "constof_MouseButton": (ref: heap.Ref<string>): number => { 325 const idx = ["left", "middle", "right"].indexOf(A.H.get(ref)); 326 return idx < 0 ? 0 : idx + 1; 327 }, 328 329 "store_OnAssistiveWindowButtonClickedArgDetails": (ptr: Pointer, ref: heap.Ref<any>) => { 330 const x = A.H.get<any>(ref); 331 332 if (typeof x === "undefined") { 333 A.store.Bool(ptr + 8, false); 334 A.store.Enum(ptr + 0, -1); 335 A.store.Enum(ptr + 4, -1); 336 } else { 337 A.store.Bool(ptr + 8, true); 338 A.store.Enum(ptr + 0, ["undo", "addToDictionary"].indexOf(x["buttonID"] as string)); 339 A.store.Enum(ptr + 4, ["undo"].indexOf(x["windowType"] as string)); 340 } 341 }, 342 "load_OnAssistiveWindowButtonClickedArgDetails": ( 343 ptr: Pointer, 344 create: heap.Ref<boolean>, 345 ref: heap.Ref<any> 346 ): heap.Ref<any> => { 347 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 348 349 x["buttonID"] = A.load.Enum(ptr + 0, ["undo", "addToDictionary"]); 350 x["windowType"] = A.load.Enum(ptr + 4, ["undo"]); 351 return create === A.H.TRUE ? A.H.push(x) : ref; 352 }, 353 354 "store_OnSurroundingTextChangedArgSurroundingInfo": (ptr: Pointer, ref: heap.Ref<any>) => { 355 const x = A.H.get<any>(ref); 356 357 if (typeof x === "undefined") { 358 A.store.Bool(ptr + 28, false); 359 A.store.Int64(ptr + 0, 0); 360 A.store.Int64(ptr + 8, 0); 361 A.store.Int64(ptr + 16, 0); 362 A.store.Ref(ptr + 24, undefined); 363 } else { 364 A.store.Bool(ptr + 28, true); 365 A.store.Int64(ptr + 0, x["anchor"] === undefined ? 0 : (x["anchor"] as number)); 366 A.store.Int64(ptr + 8, x["focus"] === undefined ? 0 : (x["focus"] as number)); 367 A.store.Int64(ptr + 16, x["offset"] === undefined ? 0 : (x["offset"] as number)); 368 A.store.Ref(ptr + 24, x["text"]); 369 } 370 }, 371 "load_OnSurroundingTextChangedArgSurroundingInfo": ( 372 ptr: Pointer, 373 create: heap.Ref<boolean>, 374 ref: heap.Ref<any> 375 ): heap.Ref<any> => { 376 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 377 378 x["anchor"] = A.load.Int64(ptr + 0); 379 x["focus"] = A.load.Int64(ptr + 8); 380 x["offset"] = A.load.Int64(ptr + 16); 381 x["text"] = A.load.Ref(ptr + 24, undefined); 382 return create === A.H.TRUE ? A.H.push(x) : ref; 383 }, 384 "constof_ScreenType": (ref: heap.Ref<string>): number => { 385 const idx = ["normal", "login", "lock", "secondary-login"].indexOf(A.H.get(ref)); 386 return idx < 0 ? 0 : idx + 1; 387 }, 388 389 "store_SendKeyEventsArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 390 const x = A.H.get<any>(ref); 391 392 if (typeof x === "undefined") { 393 A.store.Bool(ptr + 12, false); 394 A.store.Int64(ptr + 0, 0); 395 A.store.Ref(ptr + 8, undefined); 396 } else { 397 A.store.Bool(ptr + 12, true); 398 A.store.Int64(ptr + 0, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 399 A.store.Ref(ptr + 8, x["keyData"]); 400 } 401 }, 402 "load_SendKeyEventsArgParameters": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 403 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 404 405 x["contextID"] = A.load.Int64(ptr + 0); 406 x["keyData"] = A.load.Ref(ptr + 8, undefined); 407 return create === A.H.TRUE ? A.H.push(x) : ref; 408 }, 409 410 "store_SetAssistiveWindowButtonHighlightedArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 411 const x = A.H.get<any>(ref); 412 413 if (typeof x === "undefined") { 414 A.store.Bool(ptr + 24, false); 415 A.store.Ref(ptr + 0, undefined); 416 A.store.Enum(ptr + 4, -1); 417 A.store.Int64(ptr + 8, 0); 418 A.store.Bool(ptr + 16, false); 419 A.store.Enum(ptr + 20, -1); 420 } else { 421 A.store.Bool(ptr + 24, true); 422 A.store.Ref(ptr + 0, x["announceString"]); 423 A.store.Enum(ptr + 4, ["undo", "addToDictionary"].indexOf(x["buttonID"] as string)); 424 A.store.Int64(ptr + 8, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 425 A.store.Bool(ptr + 16, x["highlighted"] ? true : false); 426 A.store.Enum(ptr + 20, ["undo"].indexOf(x["windowType"] as string)); 427 } 428 }, 429 "load_SetAssistiveWindowButtonHighlightedArgParameters": ( 430 ptr: Pointer, 431 create: heap.Ref<boolean>, 432 ref: heap.Ref<any> 433 ): heap.Ref<any> => { 434 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 435 436 x["announceString"] = A.load.Ref(ptr + 0, undefined); 437 x["buttonID"] = A.load.Enum(ptr + 4, ["undo", "addToDictionary"]); 438 x["contextID"] = A.load.Int64(ptr + 8); 439 x["highlighted"] = A.load.Bool(ptr + 16); 440 x["windowType"] = A.load.Enum(ptr + 20, ["undo"]); 441 return create === A.H.TRUE ? A.H.push(x) : ref; 442 }, 443 444 "store_SetAssistiveWindowPropertiesArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 445 const x = A.H.get<any>(ref); 446 447 if (typeof x === "undefined") { 448 A.store.Bool(ptr + 18, false); 449 A.store.Int64(ptr + 0, 0); 450 451 A.store.Bool(ptr + 8 + 9, false); 452 A.store.Ref(ptr + 8 + 0, undefined); 453 A.store.Enum(ptr + 8 + 4, -1); 454 A.store.Bool(ptr + 8 + 8, false); 455 } else { 456 A.store.Bool(ptr + 18, true); 457 A.store.Int64(ptr + 0, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 458 459 if (typeof x["properties"] === "undefined") { 460 A.store.Bool(ptr + 8 + 9, false); 461 A.store.Ref(ptr + 8 + 0, undefined); 462 A.store.Enum(ptr + 8 + 4, -1); 463 A.store.Bool(ptr + 8 + 8, false); 464 } else { 465 A.store.Bool(ptr + 8 + 9, true); 466 A.store.Ref(ptr + 8 + 0, x["properties"]["announceString"]); 467 A.store.Enum(ptr + 8 + 4, ["undo"].indexOf(x["properties"]["type"] as string)); 468 A.store.Bool(ptr + 8 + 8, x["properties"]["visible"] ? true : false); 469 } 470 } 471 }, 472 "load_SetAssistiveWindowPropertiesArgParameters": ( 473 ptr: Pointer, 474 create: heap.Ref<boolean>, 475 ref: heap.Ref<any> 476 ): heap.Ref<any> => { 477 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 478 479 x["contextID"] = A.load.Int64(ptr + 0); 480 if (A.load.Bool(ptr + 8 + 9)) { 481 x["properties"] = {}; 482 x["properties"]["announceString"] = A.load.Ref(ptr + 8 + 0, undefined); 483 x["properties"]["type"] = A.load.Enum(ptr + 8 + 4, ["undo"]); 484 x["properties"]["visible"] = A.load.Bool(ptr + 8 + 8); 485 } else { 486 delete x["properties"]; 487 } 488 return create === A.H.TRUE ? A.H.push(x) : ref; 489 }, 490 "constof_WindowPosition": (ref: heap.Ref<string>): number => { 491 const idx = ["cursor", "composition"].indexOf(A.H.get(ref)); 492 return idx < 0 ? 0 : idx + 1; 493 }, 494 495 "store_SetCandidateWindowPropertiesArgParametersFieldProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 496 const x = A.H.get<any>(ref); 497 498 if (typeof x === "undefined") { 499 A.store.Bool(ptr + 55, false); 500 A.store.Ref(ptr + 0, undefined); 501 A.store.Bool(ptr + 48, false); 502 A.store.Bool(ptr + 4, false); 503 A.store.Bool(ptr + 49, false); 504 A.store.Int64(ptr + 8, 0); 505 A.store.Bool(ptr + 50, false); 506 A.store.Bool(ptr + 16, false); 507 A.store.Bool(ptr + 51, false); 508 A.store.Int64(ptr + 24, 0); 509 A.store.Bool(ptr + 52, false); 510 A.store.Int64(ptr + 32, 0); 511 A.store.Bool(ptr + 53, false); 512 A.store.Bool(ptr + 40, false); 513 A.store.Bool(ptr + 54, false); 514 A.store.Bool(ptr + 41, false); 515 A.store.Enum(ptr + 44, -1); 516 } else { 517 A.store.Bool(ptr + 55, true); 518 A.store.Ref(ptr + 0, x["auxiliaryText"]); 519 A.store.Bool(ptr + 48, "auxiliaryTextVisible" in x ? true : false); 520 A.store.Bool(ptr + 4, x["auxiliaryTextVisible"] ? true : false); 521 A.store.Bool(ptr + 49, "currentCandidateIndex" in x ? true : false); 522 A.store.Int64(ptr + 8, x["currentCandidateIndex"] === undefined ? 0 : (x["currentCandidateIndex"] as number)); 523 A.store.Bool(ptr + 50, "cursorVisible" in x ? true : false); 524 A.store.Bool(ptr + 16, x["cursorVisible"] ? true : false); 525 A.store.Bool(ptr + 51, "pageSize" in x ? true : false); 526 A.store.Int64(ptr + 24, x["pageSize"] === undefined ? 0 : (x["pageSize"] as number)); 527 A.store.Bool(ptr + 52, "totalCandidates" in x ? true : false); 528 A.store.Int64(ptr + 32, x["totalCandidates"] === undefined ? 0 : (x["totalCandidates"] as number)); 529 A.store.Bool(ptr + 53, "vertical" in x ? true : false); 530 A.store.Bool(ptr + 40, x["vertical"] ? true : false); 531 A.store.Bool(ptr + 54, "visible" in x ? true : false); 532 A.store.Bool(ptr + 41, x["visible"] ? true : false); 533 A.store.Enum(ptr + 44, ["cursor", "composition"].indexOf(x["windowPosition"] as string)); 534 } 535 }, 536 "load_SetCandidateWindowPropertiesArgParametersFieldProperties": ( 537 ptr: Pointer, 538 create: heap.Ref<boolean>, 539 ref: heap.Ref<any> 540 ): heap.Ref<any> => { 541 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 542 543 x["auxiliaryText"] = A.load.Ref(ptr + 0, undefined); 544 if (A.load.Bool(ptr + 48)) { 545 x["auxiliaryTextVisible"] = A.load.Bool(ptr + 4); 546 } else { 547 delete x["auxiliaryTextVisible"]; 548 } 549 if (A.load.Bool(ptr + 49)) { 550 x["currentCandidateIndex"] = A.load.Int64(ptr + 8); 551 } else { 552 delete x["currentCandidateIndex"]; 553 } 554 if (A.load.Bool(ptr + 50)) { 555 x["cursorVisible"] = A.load.Bool(ptr + 16); 556 } else { 557 delete x["cursorVisible"]; 558 } 559 if (A.load.Bool(ptr + 51)) { 560 x["pageSize"] = A.load.Int64(ptr + 24); 561 } else { 562 delete x["pageSize"]; 563 } 564 if (A.load.Bool(ptr + 52)) { 565 x["totalCandidates"] = A.load.Int64(ptr + 32); 566 } else { 567 delete x["totalCandidates"]; 568 } 569 if (A.load.Bool(ptr + 53)) { 570 x["vertical"] = A.load.Bool(ptr + 40); 571 } else { 572 delete x["vertical"]; 573 } 574 if (A.load.Bool(ptr + 54)) { 575 x["visible"] = A.load.Bool(ptr + 41); 576 } else { 577 delete x["visible"]; 578 } 579 x["windowPosition"] = A.load.Enum(ptr + 44, ["cursor", "composition"]); 580 return create === A.H.TRUE ? A.H.push(x) : ref; 581 }, 582 583 "store_SetCandidateWindowPropertiesArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 584 const x = A.H.get<any>(ref); 585 586 if (typeof x === "undefined") { 587 A.store.Bool(ptr + 64, false); 588 A.store.Ref(ptr + 0, undefined); 589 590 A.store.Bool(ptr + 8 + 55, false); 591 A.store.Ref(ptr + 8 + 0, undefined); 592 A.store.Bool(ptr + 8 + 48, false); 593 A.store.Bool(ptr + 8 + 4, false); 594 A.store.Bool(ptr + 8 + 49, false); 595 A.store.Int64(ptr + 8 + 8, 0); 596 A.store.Bool(ptr + 8 + 50, false); 597 A.store.Bool(ptr + 8 + 16, false); 598 A.store.Bool(ptr + 8 + 51, false); 599 A.store.Int64(ptr + 8 + 24, 0); 600 A.store.Bool(ptr + 8 + 52, false); 601 A.store.Int64(ptr + 8 + 32, 0); 602 A.store.Bool(ptr + 8 + 53, false); 603 A.store.Bool(ptr + 8 + 40, false); 604 A.store.Bool(ptr + 8 + 54, false); 605 A.store.Bool(ptr + 8 + 41, false); 606 A.store.Enum(ptr + 8 + 44, -1); 607 } else { 608 A.store.Bool(ptr + 64, true); 609 A.store.Ref(ptr + 0, x["engineID"]); 610 611 if (typeof x["properties"] === "undefined") { 612 A.store.Bool(ptr + 8 + 55, false); 613 A.store.Ref(ptr + 8 + 0, undefined); 614 A.store.Bool(ptr + 8 + 48, false); 615 A.store.Bool(ptr + 8 + 4, false); 616 A.store.Bool(ptr + 8 + 49, false); 617 A.store.Int64(ptr + 8 + 8, 0); 618 A.store.Bool(ptr + 8 + 50, false); 619 A.store.Bool(ptr + 8 + 16, false); 620 A.store.Bool(ptr + 8 + 51, false); 621 A.store.Int64(ptr + 8 + 24, 0); 622 A.store.Bool(ptr + 8 + 52, false); 623 A.store.Int64(ptr + 8 + 32, 0); 624 A.store.Bool(ptr + 8 + 53, false); 625 A.store.Bool(ptr + 8 + 40, false); 626 A.store.Bool(ptr + 8 + 54, false); 627 A.store.Bool(ptr + 8 + 41, false); 628 A.store.Enum(ptr + 8 + 44, -1); 629 } else { 630 A.store.Bool(ptr + 8 + 55, true); 631 A.store.Ref(ptr + 8 + 0, x["properties"]["auxiliaryText"]); 632 A.store.Bool(ptr + 8 + 48, "auxiliaryTextVisible" in x["properties"] ? true : false); 633 A.store.Bool(ptr + 8 + 4, x["properties"]["auxiliaryTextVisible"] ? true : false); 634 A.store.Bool(ptr + 8 + 49, "currentCandidateIndex" in x["properties"] ? true : false); 635 A.store.Int64( 636 ptr + 8 + 8, 637 x["properties"]["currentCandidateIndex"] === undefined 638 ? 0 639 : (x["properties"]["currentCandidateIndex"] as number) 640 ); 641 A.store.Bool(ptr + 8 + 50, "cursorVisible" in x["properties"] ? true : false); 642 A.store.Bool(ptr + 8 + 16, x["properties"]["cursorVisible"] ? true : false); 643 A.store.Bool(ptr + 8 + 51, "pageSize" in x["properties"] ? true : false); 644 A.store.Int64( 645 ptr + 8 + 24, 646 x["properties"]["pageSize"] === undefined ? 0 : (x["properties"]["pageSize"] as number) 647 ); 648 A.store.Bool(ptr + 8 + 52, "totalCandidates" in x["properties"] ? true : false); 649 A.store.Int64( 650 ptr + 8 + 32, 651 x["properties"]["totalCandidates"] === undefined ? 0 : (x["properties"]["totalCandidates"] as number) 652 ); 653 A.store.Bool(ptr + 8 + 53, "vertical" in x["properties"] ? true : false); 654 A.store.Bool(ptr + 8 + 40, x["properties"]["vertical"] ? true : false); 655 A.store.Bool(ptr + 8 + 54, "visible" in x["properties"] ? true : false); 656 A.store.Bool(ptr + 8 + 41, x["properties"]["visible"] ? true : false); 657 A.store.Enum(ptr + 8 + 44, ["cursor", "composition"].indexOf(x["properties"]["windowPosition"] as string)); 658 } 659 } 660 }, 661 "load_SetCandidateWindowPropertiesArgParameters": ( 662 ptr: Pointer, 663 create: heap.Ref<boolean>, 664 ref: heap.Ref<any> 665 ): heap.Ref<any> => { 666 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 667 668 x["engineID"] = A.load.Ref(ptr + 0, undefined); 669 if (A.load.Bool(ptr + 8 + 55)) { 670 x["properties"] = {}; 671 x["properties"]["auxiliaryText"] = A.load.Ref(ptr + 8 + 0, undefined); 672 if (A.load.Bool(ptr + 8 + 48)) { 673 x["properties"]["auxiliaryTextVisible"] = A.load.Bool(ptr + 8 + 4); 674 } else { 675 delete x["properties"]["auxiliaryTextVisible"]; 676 } 677 if (A.load.Bool(ptr + 8 + 49)) { 678 x["properties"]["currentCandidateIndex"] = A.load.Int64(ptr + 8 + 8); 679 } else { 680 delete x["properties"]["currentCandidateIndex"]; 681 } 682 if (A.load.Bool(ptr + 8 + 50)) { 683 x["properties"]["cursorVisible"] = A.load.Bool(ptr + 8 + 16); 684 } else { 685 delete x["properties"]["cursorVisible"]; 686 } 687 if (A.load.Bool(ptr + 8 + 51)) { 688 x["properties"]["pageSize"] = A.load.Int64(ptr + 8 + 24); 689 } else { 690 delete x["properties"]["pageSize"]; 691 } 692 if (A.load.Bool(ptr + 8 + 52)) { 693 x["properties"]["totalCandidates"] = A.load.Int64(ptr + 8 + 32); 694 } else { 695 delete x["properties"]["totalCandidates"]; 696 } 697 if (A.load.Bool(ptr + 8 + 53)) { 698 x["properties"]["vertical"] = A.load.Bool(ptr + 8 + 40); 699 } else { 700 delete x["properties"]["vertical"]; 701 } 702 if (A.load.Bool(ptr + 8 + 54)) { 703 x["properties"]["visible"] = A.load.Bool(ptr + 8 + 41); 704 } else { 705 delete x["properties"]["visible"]; 706 } 707 x["properties"]["windowPosition"] = A.load.Enum(ptr + 8 + 44, ["cursor", "composition"]); 708 } else { 709 delete x["properties"]; 710 } 711 return create === A.H.TRUE ? A.H.push(x) : ref; 712 }, 713 714 "store_SetCandidatesArgParametersFieldCandidatesElemFieldUsage": (ptr: Pointer, ref: heap.Ref<any>) => { 715 const x = A.H.get<any>(ref); 716 717 if (typeof x === "undefined") { 718 A.store.Bool(ptr + 8, false); 719 A.store.Ref(ptr + 0, undefined); 720 A.store.Ref(ptr + 4, undefined); 721 } else { 722 A.store.Bool(ptr + 8, true); 723 A.store.Ref(ptr + 0, x["body"]); 724 A.store.Ref(ptr + 4, x["title"]); 725 } 726 }, 727 "load_SetCandidatesArgParametersFieldCandidatesElemFieldUsage": ( 728 ptr: Pointer, 729 create: heap.Ref<boolean>, 730 ref: heap.Ref<any> 731 ): heap.Ref<any> => { 732 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 733 734 x["body"] = A.load.Ref(ptr + 0, undefined); 735 x["title"] = A.load.Ref(ptr + 4, undefined); 736 return create === A.H.TRUE ? A.H.push(x) : ref; 737 }, 738 739 "store_SetCandidatesArgParametersFieldCandidatesElem": (ptr: Pointer, ref: heap.Ref<any>) => { 740 const x = A.H.get<any>(ref); 741 742 if (typeof x === "undefined") { 743 A.store.Bool(ptr + 42, false); 744 A.store.Ref(ptr + 0, undefined); 745 A.store.Ref(ptr + 4, undefined); 746 A.store.Int64(ptr + 8, 0); 747 A.store.Ref(ptr + 16, undefined); 748 A.store.Bool(ptr + 41, false); 749 A.store.Int64(ptr + 24, 0); 750 751 A.store.Bool(ptr + 32 + 8, false); 752 A.store.Ref(ptr + 32 + 0, undefined); 753 A.store.Ref(ptr + 32 + 4, undefined); 754 } else { 755 A.store.Bool(ptr + 42, true); 756 A.store.Ref(ptr + 0, x["annotation"]); 757 A.store.Ref(ptr + 4, x["candidate"]); 758 A.store.Int64(ptr + 8, x["id"] === undefined ? 0 : (x["id"] as number)); 759 A.store.Ref(ptr + 16, x["label"]); 760 A.store.Bool(ptr + 41, "parentId" in x ? true : false); 761 A.store.Int64(ptr + 24, x["parentId"] === undefined ? 0 : (x["parentId"] as number)); 762 763 if (typeof x["usage"] === "undefined") { 764 A.store.Bool(ptr + 32 + 8, false); 765 A.store.Ref(ptr + 32 + 0, undefined); 766 A.store.Ref(ptr + 32 + 4, undefined); 767 } else { 768 A.store.Bool(ptr + 32 + 8, true); 769 A.store.Ref(ptr + 32 + 0, x["usage"]["body"]); 770 A.store.Ref(ptr + 32 + 4, x["usage"]["title"]); 771 } 772 } 773 }, 774 "load_SetCandidatesArgParametersFieldCandidatesElem": ( 775 ptr: Pointer, 776 create: heap.Ref<boolean>, 777 ref: heap.Ref<any> 778 ): heap.Ref<any> => { 779 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 780 781 x["annotation"] = A.load.Ref(ptr + 0, undefined); 782 x["candidate"] = A.load.Ref(ptr + 4, undefined); 783 x["id"] = A.load.Int64(ptr + 8); 784 x["label"] = A.load.Ref(ptr + 16, undefined); 785 if (A.load.Bool(ptr + 41)) { 786 x["parentId"] = A.load.Int64(ptr + 24); 787 } else { 788 delete x["parentId"]; 789 } 790 if (A.load.Bool(ptr + 32 + 8)) { 791 x["usage"] = {}; 792 x["usage"]["body"] = A.load.Ref(ptr + 32 + 0, undefined); 793 x["usage"]["title"] = A.load.Ref(ptr + 32 + 4, undefined); 794 } else { 795 delete x["usage"]; 796 } 797 return create === A.H.TRUE ? A.H.push(x) : ref; 798 }, 799 800 "store_SetCandidatesArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 801 const x = A.H.get<any>(ref); 802 803 if (typeof x === "undefined") { 804 A.store.Bool(ptr + 16, false); 805 A.store.Ref(ptr + 0, undefined); 806 A.store.Int64(ptr + 8, 0); 807 } else { 808 A.store.Bool(ptr + 16, true); 809 A.store.Ref(ptr + 0, x["candidates"]); 810 A.store.Int64(ptr + 8, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 811 } 812 }, 813 "load_SetCandidatesArgParameters": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 814 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 815 816 x["candidates"] = A.load.Ref(ptr + 0, undefined); 817 x["contextID"] = A.load.Int64(ptr + 8); 818 return create === A.H.TRUE ? A.H.push(x) : ref; 819 }, 820 "constof_UnderlineStyle": (ref: heap.Ref<string>): number => { 821 const idx = ["underline", "doubleUnderline", "noUnderline"].indexOf(A.H.get(ref)); 822 return idx < 0 ? 0 : idx + 1; 823 }, 824 825 "store_SetCompositionArgParametersFieldSegmentsElem": (ptr: Pointer, ref: heap.Ref<any>) => { 826 const x = A.H.get<any>(ref); 827 828 if (typeof x === "undefined") { 829 A.store.Bool(ptr + 20, false); 830 A.store.Int64(ptr + 0, 0); 831 A.store.Int64(ptr + 8, 0); 832 A.store.Enum(ptr + 16, -1); 833 } else { 834 A.store.Bool(ptr + 20, true); 835 A.store.Int64(ptr + 0, x["end"] === undefined ? 0 : (x["end"] as number)); 836 A.store.Int64(ptr + 8, x["start"] === undefined ? 0 : (x["start"] as number)); 837 A.store.Enum(ptr + 16, ["underline", "doubleUnderline", "noUnderline"].indexOf(x["style"] as string)); 838 } 839 }, 840 "load_SetCompositionArgParametersFieldSegmentsElem": ( 841 ptr: Pointer, 842 create: heap.Ref<boolean>, 843 ref: heap.Ref<any> 844 ): heap.Ref<any> => { 845 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 846 847 x["end"] = A.load.Int64(ptr + 0); 848 x["start"] = A.load.Int64(ptr + 8); 849 x["style"] = A.load.Enum(ptr + 16, ["underline", "doubleUnderline", "noUnderline"]); 850 return create === A.H.TRUE ? A.H.push(x) : ref; 851 }, 852 853 "store_SetCompositionArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 854 const x = A.H.get<any>(ref); 855 856 if (typeof x === "undefined") { 857 A.store.Bool(ptr + 46, false); 858 A.store.Int64(ptr + 0, 0); 859 A.store.Int64(ptr + 8, 0); 860 A.store.Ref(ptr + 16, undefined); 861 A.store.Bool(ptr + 44, false); 862 A.store.Int64(ptr + 24, 0); 863 A.store.Bool(ptr + 45, false); 864 A.store.Int64(ptr + 32, 0); 865 A.store.Ref(ptr + 40, undefined); 866 } else { 867 A.store.Bool(ptr + 46, true); 868 A.store.Int64(ptr + 0, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 869 A.store.Int64(ptr + 8, x["cursor"] === undefined ? 0 : (x["cursor"] as number)); 870 A.store.Ref(ptr + 16, x["segments"]); 871 A.store.Bool(ptr + 44, "selectionEnd" in x ? true : false); 872 A.store.Int64(ptr + 24, x["selectionEnd"] === undefined ? 0 : (x["selectionEnd"] as number)); 873 A.store.Bool(ptr + 45, "selectionStart" in x ? true : false); 874 A.store.Int64(ptr + 32, x["selectionStart"] === undefined ? 0 : (x["selectionStart"] as number)); 875 A.store.Ref(ptr + 40, x["text"]); 876 } 877 }, 878 "load_SetCompositionArgParameters": ( 879 ptr: Pointer, 880 create: heap.Ref<boolean>, 881 ref: heap.Ref<any> 882 ): heap.Ref<any> => { 883 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 884 885 x["contextID"] = A.load.Int64(ptr + 0); 886 x["cursor"] = A.load.Int64(ptr + 8); 887 x["segments"] = A.load.Ref(ptr + 16, undefined); 888 if (A.load.Bool(ptr + 44)) { 889 x["selectionEnd"] = A.load.Int64(ptr + 24); 890 } else { 891 delete x["selectionEnd"]; 892 } 893 if (A.load.Bool(ptr + 45)) { 894 x["selectionStart"] = A.load.Int64(ptr + 32); 895 } else { 896 delete x["selectionStart"]; 897 } 898 x["text"] = A.load.Ref(ptr + 40, undefined); 899 return create === A.H.TRUE ? A.H.push(x) : ref; 900 }, 901 902 "store_SetCursorPositionArgParameters": (ptr: Pointer, ref: heap.Ref<any>) => { 903 const x = A.H.get<any>(ref); 904 905 if (typeof x === "undefined") { 906 A.store.Bool(ptr + 16, false); 907 A.store.Int64(ptr + 0, 0); 908 A.store.Int64(ptr + 8, 0); 909 } else { 910 A.store.Bool(ptr + 16, true); 911 A.store.Int64(ptr + 0, x["candidateID"] === undefined ? 0 : (x["candidateID"] as number)); 912 A.store.Int64(ptr + 8, x["contextID"] === undefined ? 0 : (x["contextID"] as number)); 913 } 914 }, 915 "load_SetCursorPositionArgParameters": ( 916 ptr: Pointer, 917 create: heap.Ref<boolean>, 918 ref: heap.Ref<any> 919 ): heap.Ref<any> => { 920 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 921 922 x["candidateID"] = A.load.Int64(ptr + 0); 923 x["contextID"] = A.load.Int64(ptr + 8); 924 return create === A.H.TRUE ? A.H.push(x) : ref; 925 }, 926 "has_ClearComposition": (): heap.Ref<boolean> => { 927 if (WEBEXT?.input?.ime && "clearComposition" in WEBEXT?.input?.ime) { 928 return A.H.TRUE; 929 } 930 return A.H.FALSE; 931 }, 932 "func_ClearComposition": (fn: Pointer): void => { 933 A.store.Ref(fn, WEBEXT.input.ime.clearComposition); 934 }, 935 "call_ClearComposition": (retPtr: Pointer, parameters: Pointer): void => { 936 const parameters_ffi = {}; 937 938 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 939 940 const _ret = WEBEXT.input.ime.clearComposition(parameters_ffi); 941 A.store.Ref(retPtr, _ret); 942 }, 943 "try_ClearComposition": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 944 try { 945 const parameters_ffi = {}; 946 947 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 948 949 const _ret = WEBEXT.input.ime.clearComposition(parameters_ffi); 950 A.store.Ref(retPtr, _ret); 951 return A.H.TRUE; 952 } catch (err: any) { 953 A.store.Ref(errPtr, err); 954 return A.H.FALSE; 955 } 956 }, 957 "has_CommitText": (): heap.Ref<boolean> => { 958 if (WEBEXT?.input?.ime && "commitText" in WEBEXT?.input?.ime) { 959 return A.H.TRUE; 960 } 961 return A.H.FALSE; 962 }, 963 "func_CommitText": (fn: Pointer): void => { 964 A.store.Ref(fn, WEBEXT.input.ime.commitText); 965 }, 966 "call_CommitText": (retPtr: Pointer, parameters: Pointer): void => { 967 const parameters_ffi = {}; 968 969 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 970 parameters_ffi["text"] = A.load.Ref(parameters + 8, undefined); 971 972 const _ret = WEBEXT.input.ime.commitText(parameters_ffi); 973 A.store.Ref(retPtr, _ret); 974 }, 975 "try_CommitText": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 976 try { 977 const parameters_ffi = {}; 978 979 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 980 parameters_ffi["text"] = A.load.Ref(parameters + 8, undefined); 981 982 const _ret = WEBEXT.input.ime.commitText(parameters_ffi); 983 A.store.Ref(retPtr, _ret); 984 return A.H.TRUE; 985 } catch (err: any) { 986 A.store.Ref(errPtr, err); 987 return A.H.FALSE; 988 } 989 }, 990 "has_DeleteSurroundingText": (): heap.Ref<boolean> => { 991 if (WEBEXT?.input?.ime && "deleteSurroundingText" in WEBEXT?.input?.ime) { 992 return A.H.TRUE; 993 } 994 return A.H.FALSE; 995 }, 996 "func_DeleteSurroundingText": (fn: Pointer): void => { 997 A.store.Ref(fn, WEBEXT.input.ime.deleteSurroundingText); 998 }, 999 "call_DeleteSurroundingText": (retPtr: Pointer, parameters: Pointer): void => { 1000 const parameters_ffi = {}; 1001 1002 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1003 parameters_ffi["engineID"] = A.load.Ref(parameters + 8, undefined); 1004 parameters_ffi["length"] = A.load.Int64(parameters + 16); 1005 parameters_ffi["offset"] = A.load.Int64(parameters + 24); 1006 1007 const _ret = WEBEXT.input.ime.deleteSurroundingText(parameters_ffi); 1008 A.store.Ref(retPtr, _ret); 1009 }, 1010 "try_DeleteSurroundingText": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 1011 try { 1012 const parameters_ffi = {}; 1013 1014 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1015 parameters_ffi["engineID"] = A.load.Ref(parameters + 8, undefined); 1016 parameters_ffi["length"] = A.load.Int64(parameters + 16); 1017 parameters_ffi["offset"] = A.load.Int64(parameters + 24); 1018 1019 const _ret = WEBEXT.input.ime.deleteSurroundingText(parameters_ffi); 1020 A.store.Ref(retPtr, _ret); 1021 return A.H.TRUE; 1022 } catch (err: any) { 1023 A.store.Ref(errPtr, err); 1024 return A.H.FALSE; 1025 } 1026 }, 1027 "has_HideInputView": (): heap.Ref<boolean> => { 1028 if (WEBEXT?.input?.ime && "hideInputView" in WEBEXT?.input?.ime) { 1029 return A.H.TRUE; 1030 } 1031 return A.H.FALSE; 1032 }, 1033 "func_HideInputView": (fn: Pointer): void => { 1034 A.store.Ref(fn, WEBEXT.input.ime.hideInputView); 1035 }, 1036 "call_HideInputView": (retPtr: Pointer): void => { 1037 const _ret = WEBEXT.input.ime.hideInputView(); 1038 }, 1039 "try_HideInputView": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => { 1040 try { 1041 const _ret = WEBEXT.input.ime.hideInputView(); 1042 return A.H.TRUE; 1043 } catch (err: any) { 1044 A.store.Ref(errPtr, err); 1045 return A.H.FALSE; 1046 } 1047 }, 1048 "has_KeyEventHandled": (): heap.Ref<boolean> => { 1049 if (WEBEXT?.input?.ime && "keyEventHandled" in WEBEXT?.input?.ime) { 1050 return A.H.TRUE; 1051 } 1052 return A.H.FALSE; 1053 }, 1054 "func_KeyEventHandled": (fn: Pointer): void => { 1055 A.store.Ref(fn, WEBEXT.input.ime.keyEventHandled); 1056 }, 1057 "call_KeyEventHandled": (retPtr: Pointer, requestId: heap.Ref<object>, response: heap.Ref<boolean>): void => { 1058 const _ret = WEBEXT.input.ime.keyEventHandled(A.H.get<object>(requestId), response === A.H.TRUE); 1059 }, 1060 "try_KeyEventHandled": ( 1061 retPtr: Pointer, 1062 errPtr: Pointer, 1063 requestId: heap.Ref<object>, 1064 response: heap.Ref<boolean> 1065 ): heap.Ref<boolean> => { 1066 try { 1067 const _ret = WEBEXT.input.ime.keyEventHandled(A.H.get<object>(requestId), response === A.H.TRUE); 1068 return A.H.TRUE; 1069 } catch (err: any) { 1070 A.store.Ref(errPtr, err); 1071 return A.H.FALSE; 1072 } 1073 }, 1074 "has_OnActivate": (): heap.Ref<boolean> => { 1075 if (WEBEXT?.input?.ime?.onActivate && "addListener" in WEBEXT?.input?.ime?.onActivate) { 1076 return A.H.TRUE; 1077 } 1078 return A.H.FALSE; 1079 }, 1080 "func_OnActivate": (fn: Pointer): void => { 1081 A.store.Ref(fn, WEBEXT.input.ime.onActivate.addListener); 1082 }, 1083 "call_OnActivate": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1084 const _ret = WEBEXT.input.ime.onActivate.addListener(A.H.get<object>(callback)); 1085 }, 1086 "try_OnActivate": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1087 try { 1088 const _ret = WEBEXT.input.ime.onActivate.addListener(A.H.get<object>(callback)); 1089 return A.H.TRUE; 1090 } catch (err: any) { 1091 A.store.Ref(errPtr, err); 1092 return A.H.FALSE; 1093 } 1094 }, 1095 "has_OffActivate": (): heap.Ref<boolean> => { 1096 if (WEBEXT?.input?.ime?.onActivate && "removeListener" in WEBEXT?.input?.ime?.onActivate) { 1097 return A.H.TRUE; 1098 } 1099 return A.H.FALSE; 1100 }, 1101 "func_OffActivate": (fn: Pointer): void => { 1102 A.store.Ref(fn, WEBEXT.input.ime.onActivate.removeListener); 1103 }, 1104 "call_OffActivate": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1105 const _ret = WEBEXT.input.ime.onActivate.removeListener(A.H.get<object>(callback)); 1106 }, 1107 "try_OffActivate": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1108 try { 1109 const _ret = WEBEXT.input.ime.onActivate.removeListener(A.H.get<object>(callback)); 1110 return A.H.TRUE; 1111 } catch (err: any) { 1112 A.store.Ref(errPtr, err); 1113 return A.H.FALSE; 1114 } 1115 }, 1116 "has_HasOnActivate": (): heap.Ref<boolean> => { 1117 if (WEBEXT?.input?.ime?.onActivate && "hasListener" in WEBEXT?.input?.ime?.onActivate) { 1118 return A.H.TRUE; 1119 } 1120 return A.H.FALSE; 1121 }, 1122 "func_HasOnActivate": (fn: Pointer): void => { 1123 A.store.Ref(fn, WEBEXT.input.ime.onActivate.hasListener); 1124 }, 1125 "call_HasOnActivate": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1126 const _ret = WEBEXT.input.ime.onActivate.hasListener(A.H.get<object>(callback)); 1127 A.store.Bool(retPtr, _ret); 1128 }, 1129 "try_HasOnActivate": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1130 try { 1131 const _ret = WEBEXT.input.ime.onActivate.hasListener(A.H.get<object>(callback)); 1132 A.store.Bool(retPtr, _ret); 1133 return A.H.TRUE; 1134 } catch (err: any) { 1135 A.store.Ref(errPtr, err); 1136 return A.H.FALSE; 1137 } 1138 }, 1139 "has_OnAssistiveWindowButtonClicked": (): heap.Ref<boolean> => { 1140 if ( 1141 WEBEXT?.input?.ime?.onAssistiveWindowButtonClicked && 1142 "addListener" in WEBEXT?.input?.ime?.onAssistiveWindowButtonClicked 1143 ) { 1144 return A.H.TRUE; 1145 } 1146 return A.H.FALSE; 1147 }, 1148 "func_OnAssistiveWindowButtonClicked": (fn: Pointer): void => { 1149 A.store.Ref(fn, WEBEXT.input.ime.onAssistiveWindowButtonClicked.addListener); 1150 }, 1151 "call_OnAssistiveWindowButtonClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1152 const _ret = WEBEXT.input.ime.onAssistiveWindowButtonClicked.addListener(A.H.get<object>(callback)); 1153 }, 1154 "try_OnAssistiveWindowButtonClicked": ( 1155 retPtr: Pointer, 1156 errPtr: Pointer, 1157 callback: heap.Ref<object> 1158 ): heap.Ref<boolean> => { 1159 try { 1160 const _ret = WEBEXT.input.ime.onAssistiveWindowButtonClicked.addListener(A.H.get<object>(callback)); 1161 return A.H.TRUE; 1162 } catch (err: any) { 1163 A.store.Ref(errPtr, err); 1164 return A.H.FALSE; 1165 } 1166 }, 1167 "has_OffAssistiveWindowButtonClicked": (): heap.Ref<boolean> => { 1168 if ( 1169 WEBEXT?.input?.ime?.onAssistiveWindowButtonClicked && 1170 "removeListener" in WEBEXT?.input?.ime?.onAssistiveWindowButtonClicked 1171 ) { 1172 return A.H.TRUE; 1173 } 1174 return A.H.FALSE; 1175 }, 1176 "func_OffAssistiveWindowButtonClicked": (fn: Pointer): void => { 1177 A.store.Ref(fn, WEBEXT.input.ime.onAssistiveWindowButtonClicked.removeListener); 1178 }, 1179 "call_OffAssistiveWindowButtonClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1180 const _ret = WEBEXT.input.ime.onAssistiveWindowButtonClicked.removeListener(A.H.get<object>(callback)); 1181 }, 1182 "try_OffAssistiveWindowButtonClicked": ( 1183 retPtr: Pointer, 1184 errPtr: Pointer, 1185 callback: heap.Ref<object> 1186 ): heap.Ref<boolean> => { 1187 try { 1188 const _ret = WEBEXT.input.ime.onAssistiveWindowButtonClicked.removeListener(A.H.get<object>(callback)); 1189 return A.H.TRUE; 1190 } catch (err: any) { 1191 A.store.Ref(errPtr, err); 1192 return A.H.FALSE; 1193 } 1194 }, 1195 "has_HasOnAssistiveWindowButtonClicked": (): heap.Ref<boolean> => { 1196 if ( 1197 WEBEXT?.input?.ime?.onAssistiveWindowButtonClicked && 1198 "hasListener" in WEBEXT?.input?.ime?.onAssistiveWindowButtonClicked 1199 ) { 1200 return A.H.TRUE; 1201 } 1202 return A.H.FALSE; 1203 }, 1204 "func_HasOnAssistiveWindowButtonClicked": (fn: Pointer): void => { 1205 A.store.Ref(fn, WEBEXT.input.ime.onAssistiveWindowButtonClicked.hasListener); 1206 }, 1207 "call_HasOnAssistiveWindowButtonClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1208 const _ret = WEBEXT.input.ime.onAssistiveWindowButtonClicked.hasListener(A.H.get<object>(callback)); 1209 A.store.Bool(retPtr, _ret); 1210 }, 1211 "try_HasOnAssistiveWindowButtonClicked": ( 1212 retPtr: Pointer, 1213 errPtr: Pointer, 1214 callback: heap.Ref<object> 1215 ): heap.Ref<boolean> => { 1216 try { 1217 const _ret = WEBEXT.input.ime.onAssistiveWindowButtonClicked.hasListener(A.H.get<object>(callback)); 1218 A.store.Bool(retPtr, _ret); 1219 return A.H.TRUE; 1220 } catch (err: any) { 1221 A.store.Ref(errPtr, err); 1222 return A.H.FALSE; 1223 } 1224 }, 1225 "has_OnBlur": (): heap.Ref<boolean> => { 1226 if (WEBEXT?.input?.ime?.onBlur && "addListener" in WEBEXT?.input?.ime?.onBlur) { 1227 return A.H.TRUE; 1228 } 1229 return A.H.FALSE; 1230 }, 1231 "func_OnBlur": (fn: Pointer): void => { 1232 A.store.Ref(fn, WEBEXT.input.ime.onBlur.addListener); 1233 }, 1234 "call_OnBlur": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1235 const _ret = WEBEXT.input.ime.onBlur.addListener(A.H.get<object>(callback)); 1236 }, 1237 "try_OnBlur": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1238 try { 1239 const _ret = WEBEXT.input.ime.onBlur.addListener(A.H.get<object>(callback)); 1240 return A.H.TRUE; 1241 } catch (err: any) { 1242 A.store.Ref(errPtr, err); 1243 return A.H.FALSE; 1244 } 1245 }, 1246 "has_OffBlur": (): heap.Ref<boolean> => { 1247 if (WEBEXT?.input?.ime?.onBlur && "removeListener" in WEBEXT?.input?.ime?.onBlur) { 1248 return A.H.TRUE; 1249 } 1250 return A.H.FALSE; 1251 }, 1252 "func_OffBlur": (fn: Pointer): void => { 1253 A.store.Ref(fn, WEBEXT.input.ime.onBlur.removeListener); 1254 }, 1255 "call_OffBlur": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1256 const _ret = WEBEXT.input.ime.onBlur.removeListener(A.H.get<object>(callback)); 1257 }, 1258 "try_OffBlur": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1259 try { 1260 const _ret = WEBEXT.input.ime.onBlur.removeListener(A.H.get<object>(callback)); 1261 return A.H.TRUE; 1262 } catch (err: any) { 1263 A.store.Ref(errPtr, err); 1264 return A.H.FALSE; 1265 } 1266 }, 1267 "has_HasOnBlur": (): heap.Ref<boolean> => { 1268 if (WEBEXT?.input?.ime?.onBlur && "hasListener" in WEBEXT?.input?.ime?.onBlur) { 1269 return A.H.TRUE; 1270 } 1271 return A.H.FALSE; 1272 }, 1273 "func_HasOnBlur": (fn: Pointer): void => { 1274 A.store.Ref(fn, WEBEXT.input.ime.onBlur.hasListener); 1275 }, 1276 "call_HasOnBlur": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1277 const _ret = WEBEXT.input.ime.onBlur.hasListener(A.H.get<object>(callback)); 1278 A.store.Bool(retPtr, _ret); 1279 }, 1280 "try_HasOnBlur": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1281 try { 1282 const _ret = WEBEXT.input.ime.onBlur.hasListener(A.H.get<object>(callback)); 1283 A.store.Bool(retPtr, _ret); 1284 return A.H.TRUE; 1285 } catch (err: any) { 1286 A.store.Ref(errPtr, err); 1287 return A.H.FALSE; 1288 } 1289 }, 1290 "has_OnCandidateClicked": (): heap.Ref<boolean> => { 1291 if (WEBEXT?.input?.ime?.onCandidateClicked && "addListener" in WEBEXT?.input?.ime?.onCandidateClicked) { 1292 return A.H.TRUE; 1293 } 1294 return A.H.FALSE; 1295 }, 1296 "func_OnCandidateClicked": (fn: Pointer): void => { 1297 A.store.Ref(fn, WEBEXT.input.ime.onCandidateClicked.addListener); 1298 }, 1299 "call_OnCandidateClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1300 const _ret = WEBEXT.input.ime.onCandidateClicked.addListener(A.H.get<object>(callback)); 1301 }, 1302 "try_OnCandidateClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1303 try { 1304 const _ret = WEBEXT.input.ime.onCandidateClicked.addListener(A.H.get<object>(callback)); 1305 return A.H.TRUE; 1306 } catch (err: any) { 1307 A.store.Ref(errPtr, err); 1308 return A.H.FALSE; 1309 } 1310 }, 1311 "has_OffCandidateClicked": (): heap.Ref<boolean> => { 1312 if (WEBEXT?.input?.ime?.onCandidateClicked && "removeListener" in WEBEXT?.input?.ime?.onCandidateClicked) { 1313 return A.H.TRUE; 1314 } 1315 return A.H.FALSE; 1316 }, 1317 "func_OffCandidateClicked": (fn: Pointer): void => { 1318 A.store.Ref(fn, WEBEXT.input.ime.onCandidateClicked.removeListener); 1319 }, 1320 "call_OffCandidateClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1321 const _ret = WEBEXT.input.ime.onCandidateClicked.removeListener(A.H.get<object>(callback)); 1322 }, 1323 "try_OffCandidateClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1324 try { 1325 const _ret = WEBEXT.input.ime.onCandidateClicked.removeListener(A.H.get<object>(callback)); 1326 return A.H.TRUE; 1327 } catch (err: any) { 1328 A.store.Ref(errPtr, err); 1329 return A.H.FALSE; 1330 } 1331 }, 1332 "has_HasOnCandidateClicked": (): heap.Ref<boolean> => { 1333 if (WEBEXT?.input?.ime?.onCandidateClicked && "hasListener" in WEBEXT?.input?.ime?.onCandidateClicked) { 1334 return A.H.TRUE; 1335 } 1336 return A.H.FALSE; 1337 }, 1338 "func_HasOnCandidateClicked": (fn: Pointer): void => { 1339 A.store.Ref(fn, WEBEXT.input.ime.onCandidateClicked.hasListener); 1340 }, 1341 "call_HasOnCandidateClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1342 const _ret = WEBEXT.input.ime.onCandidateClicked.hasListener(A.H.get<object>(callback)); 1343 A.store.Bool(retPtr, _ret); 1344 }, 1345 "try_HasOnCandidateClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1346 try { 1347 const _ret = WEBEXT.input.ime.onCandidateClicked.hasListener(A.H.get<object>(callback)); 1348 A.store.Bool(retPtr, _ret); 1349 return A.H.TRUE; 1350 } catch (err: any) { 1351 A.store.Ref(errPtr, err); 1352 return A.H.FALSE; 1353 } 1354 }, 1355 "has_OnDeactivated": (): heap.Ref<boolean> => { 1356 if (WEBEXT?.input?.ime?.onDeactivated && "addListener" in WEBEXT?.input?.ime?.onDeactivated) { 1357 return A.H.TRUE; 1358 } 1359 return A.H.FALSE; 1360 }, 1361 "func_OnDeactivated": (fn: Pointer): void => { 1362 A.store.Ref(fn, WEBEXT.input.ime.onDeactivated.addListener); 1363 }, 1364 "call_OnDeactivated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1365 const _ret = WEBEXT.input.ime.onDeactivated.addListener(A.H.get<object>(callback)); 1366 }, 1367 "try_OnDeactivated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1368 try { 1369 const _ret = WEBEXT.input.ime.onDeactivated.addListener(A.H.get<object>(callback)); 1370 return A.H.TRUE; 1371 } catch (err: any) { 1372 A.store.Ref(errPtr, err); 1373 return A.H.FALSE; 1374 } 1375 }, 1376 "has_OffDeactivated": (): heap.Ref<boolean> => { 1377 if (WEBEXT?.input?.ime?.onDeactivated && "removeListener" in WEBEXT?.input?.ime?.onDeactivated) { 1378 return A.H.TRUE; 1379 } 1380 return A.H.FALSE; 1381 }, 1382 "func_OffDeactivated": (fn: Pointer): void => { 1383 A.store.Ref(fn, WEBEXT.input.ime.onDeactivated.removeListener); 1384 }, 1385 "call_OffDeactivated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1386 const _ret = WEBEXT.input.ime.onDeactivated.removeListener(A.H.get<object>(callback)); 1387 }, 1388 "try_OffDeactivated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1389 try { 1390 const _ret = WEBEXT.input.ime.onDeactivated.removeListener(A.H.get<object>(callback)); 1391 return A.H.TRUE; 1392 } catch (err: any) { 1393 A.store.Ref(errPtr, err); 1394 return A.H.FALSE; 1395 } 1396 }, 1397 "has_HasOnDeactivated": (): heap.Ref<boolean> => { 1398 if (WEBEXT?.input?.ime?.onDeactivated && "hasListener" in WEBEXT?.input?.ime?.onDeactivated) { 1399 return A.H.TRUE; 1400 } 1401 return A.H.FALSE; 1402 }, 1403 "func_HasOnDeactivated": (fn: Pointer): void => { 1404 A.store.Ref(fn, WEBEXT.input.ime.onDeactivated.hasListener); 1405 }, 1406 "call_HasOnDeactivated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1407 const _ret = WEBEXT.input.ime.onDeactivated.hasListener(A.H.get<object>(callback)); 1408 A.store.Bool(retPtr, _ret); 1409 }, 1410 "try_HasOnDeactivated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1411 try { 1412 const _ret = WEBEXT.input.ime.onDeactivated.hasListener(A.H.get<object>(callback)); 1413 A.store.Bool(retPtr, _ret); 1414 return A.H.TRUE; 1415 } catch (err: any) { 1416 A.store.Ref(errPtr, err); 1417 return A.H.FALSE; 1418 } 1419 }, 1420 "has_OnFocus": (): heap.Ref<boolean> => { 1421 if (WEBEXT?.input?.ime?.onFocus && "addListener" in WEBEXT?.input?.ime?.onFocus) { 1422 return A.H.TRUE; 1423 } 1424 return A.H.FALSE; 1425 }, 1426 "func_OnFocus": (fn: Pointer): void => { 1427 A.store.Ref(fn, WEBEXT.input.ime.onFocus.addListener); 1428 }, 1429 "call_OnFocus": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1430 const _ret = WEBEXT.input.ime.onFocus.addListener(A.H.get<object>(callback)); 1431 }, 1432 "try_OnFocus": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1433 try { 1434 const _ret = WEBEXT.input.ime.onFocus.addListener(A.H.get<object>(callback)); 1435 return A.H.TRUE; 1436 } catch (err: any) { 1437 A.store.Ref(errPtr, err); 1438 return A.H.FALSE; 1439 } 1440 }, 1441 "has_OffFocus": (): heap.Ref<boolean> => { 1442 if (WEBEXT?.input?.ime?.onFocus && "removeListener" in WEBEXT?.input?.ime?.onFocus) { 1443 return A.H.TRUE; 1444 } 1445 return A.H.FALSE; 1446 }, 1447 "func_OffFocus": (fn: Pointer): void => { 1448 A.store.Ref(fn, WEBEXT.input.ime.onFocus.removeListener); 1449 }, 1450 "call_OffFocus": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1451 const _ret = WEBEXT.input.ime.onFocus.removeListener(A.H.get<object>(callback)); 1452 }, 1453 "try_OffFocus": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1454 try { 1455 const _ret = WEBEXT.input.ime.onFocus.removeListener(A.H.get<object>(callback)); 1456 return A.H.TRUE; 1457 } catch (err: any) { 1458 A.store.Ref(errPtr, err); 1459 return A.H.FALSE; 1460 } 1461 }, 1462 "has_HasOnFocus": (): heap.Ref<boolean> => { 1463 if (WEBEXT?.input?.ime?.onFocus && "hasListener" in WEBEXT?.input?.ime?.onFocus) { 1464 return A.H.TRUE; 1465 } 1466 return A.H.FALSE; 1467 }, 1468 "func_HasOnFocus": (fn: Pointer): void => { 1469 A.store.Ref(fn, WEBEXT.input.ime.onFocus.hasListener); 1470 }, 1471 "call_HasOnFocus": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1472 const _ret = WEBEXT.input.ime.onFocus.hasListener(A.H.get<object>(callback)); 1473 A.store.Bool(retPtr, _ret); 1474 }, 1475 "try_HasOnFocus": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1476 try { 1477 const _ret = WEBEXT.input.ime.onFocus.hasListener(A.H.get<object>(callback)); 1478 A.store.Bool(retPtr, _ret); 1479 return A.H.TRUE; 1480 } catch (err: any) { 1481 A.store.Ref(errPtr, err); 1482 return A.H.FALSE; 1483 } 1484 }, 1485 "has_OnInputContextUpdate": (): heap.Ref<boolean> => { 1486 if (WEBEXT?.input?.ime?.onInputContextUpdate && "addListener" in WEBEXT?.input?.ime?.onInputContextUpdate) { 1487 return A.H.TRUE; 1488 } 1489 return A.H.FALSE; 1490 }, 1491 "func_OnInputContextUpdate": (fn: Pointer): void => { 1492 A.store.Ref(fn, WEBEXT.input.ime.onInputContextUpdate.addListener); 1493 }, 1494 "call_OnInputContextUpdate": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1495 const _ret = WEBEXT.input.ime.onInputContextUpdate.addListener(A.H.get<object>(callback)); 1496 }, 1497 "try_OnInputContextUpdate": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1498 try { 1499 const _ret = WEBEXT.input.ime.onInputContextUpdate.addListener(A.H.get<object>(callback)); 1500 return A.H.TRUE; 1501 } catch (err: any) { 1502 A.store.Ref(errPtr, err); 1503 return A.H.FALSE; 1504 } 1505 }, 1506 "has_OffInputContextUpdate": (): heap.Ref<boolean> => { 1507 if (WEBEXT?.input?.ime?.onInputContextUpdate && "removeListener" in WEBEXT?.input?.ime?.onInputContextUpdate) { 1508 return A.H.TRUE; 1509 } 1510 return A.H.FALSE; 1511 }, 1512 "func_OffInputContextUpdate": (fn: Pointer): void => { 1513 A.store.Ref(fn, WEBEXT.input.ime.onInputContextUpdate.removeListener); 1514 }, 1515 "call_OffInputContextUpdate": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1516 const _ret = WEBEXT.input.ime.onInputContextUpdate.removeListener(A.H.get<object>(callback)); 1517 }, 1518 "try_OffInputContextUpdate": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1519 try { 1520 const _ret = WEBEXT.input.ime.onInputContextUpdate.removeListener(A.H.get<object>(callback)); 1521 return A.H.TRUE; 1522 } catch (err: any) { 1523 A.store.Ref(errPtr, err); 1524 return A.H.FALSE; 1525 } 1526 }, 1527 "has_HasOnInputContextUpdate": (): heap.Ref<boolean> => { 1528 if (WEBEXT?.input?.ime?.onInputContextUpdate && "hasListener" in WEBEXT?.input?.ime?.onInputContextUpdate) { 1529 return A.H.TRUE; 1530 } 1531 return A.H.FALSE; 1532 }, 1533 "func_HasOnInputContextUpdate": (fn: Pointer): void => { 1534 A.store.Ref(fn, WEBEXT.input.ime.onInputContextUpdate.hasListener); 1535 }, 1536 "call_HasOnInputContextUpdate": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1537 const _ret = WEBEXT.input.ime.onInputContextUpdate.hasListener(A.H.get<object>(callback)); 1538 A.store.Bool(retPtr, _ret); 1539 }, 1540 "try_HasOnInputContextUpdate": ( 1541 retPtr: Pointer, 1542 errPtr: Pointer, 1543 callback: heap.Ref<object> 1544 ): heap.Ref<boolean> => { 1545 try { 1546 const _ret = WEBEXT.input.ime.onInputContextUpdate.hasListener(A.H.get<object>(callback)); 1547 A.store.Bool(retPtr, _ret); 1548 return A.H.TRUE; 1549 } catch (err: any) { 1550 A.store.Ref(errPtr, err); 1551 return A.H.FALSE; 1552 } 1553 }, 1554 "has_OnKeyEvent": (): heap.Ref<boolean> => { 1555 if (WEBEXT?.input?.ime?.onKeyEvent && "addListener" in WEBEXT?.input?.ime?.onKeyEvent) { 1556 return A.H.TRUE; 1557 } 1558 return A.H.FALSE; 1559 }, 1560 "func_OnKeyEvent": (fn: Pointer): void => { 1561 A.store.Ref(fn, WEBEXT.input.ime.onKeyEvent.addListener); 1562 }, 1563 "call_OnKeyEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1564 const _ret = WEBEXT.input.ime.onKeyEvent.addListener(A.H.get<object>(callback)); 1565 }, 1566 "try_OnKeyEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1567 try { 1568 const _ret = WEBEXT.input.ime.onKeyEvent.addListener(A.H.get<object>(callback)); 1569 return A.H.TRUE; 1570 } catch (err: any) { 1571 A.store.Ref(errPtr, err); 1572 return A.H.FALSE; 1573 } 1574 }, 1575 "has_OffKeyEvent": (): heap.Ref<boolean> => { 1576 if (WEBEXT?.input?.ime?.onKeyEvent && "removeListener" in WEBEXT?.input?.ime?.onKeyEvent) { 1577 return A.H.TRUE; 1578 } 1579 return A.H.FALSE; 1580 }, 1581 "func_OffKeyEvent": (fn: Pointer): void => { 1582 A.store.Ref(fn, WEBEXT.input.ime.onKeyEvent.removeListener); 1583 }, 1584 "call_OffKeyEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1585 const _ret = WEBEXT.input.ime.onKeyEvent.removeListener(A.H.get<object>(callback)); 1586 }, 1587 "try_OffKeyEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1588 try { 1589 const _ret = WEBEXT.input.ime.onKeyEvent.removeListener(A.H.get<object>(callback)); 1590 return A.H.TRUE; 1591 } catch (err: any) { 1592 A.store.Ref(errPtr, err); 1593 return A.H.FALSE; 1594 } 1595 }, 1596 "has_HasOnKeyEvent": (): heap.Ref<boolean> => { 1597 if (WEBEXT?.input?.ime?.onKeyEvent && "hasListener" in WEBEXT?.input?.ime?.onKeyEvent) { 1598 return A.H.TRUE; 1599 } 1600 return A.H.FALSE; 1601 }, 1602 "func_HasOnKeyEvent": (fn: Pointer): void => { 1603 A.store.Ref(fn, WEBEXT.input.ime.onKeyEvent.hasListener); 1604 }, 1605 "call_HasOnKeyEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1606 const _ret = WEBEXT.input.ime.onKeyEvent.hasListener(A.H.get<object>(callback)); 1607 A.store.Bool(retPtr, _ret); 1608 }, 1609 "try_HasOnKeyEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1610 try { 1611 const _ret = WEBEXT.input.ime.onKeyEvent.hasListener(A.H.get<object>(callback)); 1612 A.store.Bool(retPtr, _ret); 1613 return A.H.TRUE; 1614 } catch (err: any) { 1615 A.store.Ref(errPtr, err); 1616 return A.H.FALSE; 1617 } 1618 }, 1619 "has_OnMenuItemActivated": (): heap.Ref<boolean> => { 1620 if (WEBEXT?.input?.ime?.onMenuItemActivated && "addListener" in WEBEXT?.input?.ime?.onMenuItemActivated) { 1621 return A.H.TRUE; 1622 } 1623 return A.H.FALSE; 1624 }, 1625 "func_OnMenuItemActivated": (fn: Pointer): void => { 1626 A.store.Ref(fn, WEBEXT.input.ime.onMenuItemActivated.addListener); 1627 }, 1628 "call_OnMenuItemActivated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1629 const _ret = WEBEXT.input.ime.onMenuItemActivated.addListener(A.H.get<object>(callback)); 1630 }, 1631 "try_OnMenuItemActivated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1632 try { 1633 const _ret = WEBEXT.input.ime.onMenuItemActivated.addListener(A.H.get<object>(callback)); 1634 return A.H.TRUE; 1635 } catch (err: any) { 1636 A.store.Ref(errPtr, err); 1637 return A.H.FALSE; 1638 } 1639 }, 1640 "has_OffMenuItemActivated": (): heap.Ref<boolean> => { 1641 if (WEBEXT?.input?.ime?.onMenuItemActivated && "removeListener" in WEBEXT?.input?.ime?.onMenuItemActivated) { 1642 return A.H.TRUE; 1643 } 1644 return A.H.FALSE; 1645 }, 1646 "func_OffMenuItemActivated": (fn: Pointer): void => { 1647 A.store.Ref(fn, WEBEXT.input.ime.onMenuItemActivated.removeListener); 1648 }, 1649 "call_OffMenuItemActivated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1650 const _ret = WEBEXT.input.ime.onMenuItemActivated.removeListener(A.H.get<object>(callback)); 1651 }, 1652 "try_OffMenuItemActivated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1653 try { 1654 const _ret = WEBEXT.input.ime.onMenuItemActivated.removeListener(A.H.get<object>(callback)); 1655 return A.H.TRUE; 1656 } catch (err: any) { 1657 A.store.Ref(errPtr, err); 1658 return A.H.FALSE; 1659 } 1660 }, 1661 "has_HasOnMenuItemActivated": (): heap.Ref<boolean> => { 1662 if (WEBEXT?.input?.ime?.onMenuItemActivated && "hasListener" in WEBEXT?.input?.ime?.onMenuItemActivated) { 1663 return A.H.TRUE; 1664 } 1665 return A.H.FALSE; 1666 }, 1667 "func_HasOnMenuItemActivated": (fn: Pointer): void => { 1668 A.store.Ref(fn, WEBEXT.input.ime.onMenuItemActivated.hasListener); 1669 }, 1670 "call_HasOnMenuItemActivated": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1671 const _ret = WEBEXT.input.ime.onMenuItemActivated.hasListener(A.H.get<object>(callback)); 1672 A.store.Bool(retPtr, _ret); 1673 }, 1674 "try_HasOnMenuItemActivated": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1675 try { 1676 const _ret = WEBEXT.input.ime.onMenuItemActivated.hasListener(A.H.get<object>(callback)); 1677 A.store.Bool(retPtr, _ret); 1678 return A.H.TRUE; 1679 } catch (err: any) { 1680 A.store.Ref(errPtr, err); 1681 return A.H.FALSE; 1682 } 1683 }, 1684 "has_OnReset": (): heap.Ref<boolean> => { 1685 if (WEBEXT?.input?.ime?.onReset && "addListener" in WEBEXT?.input?.ime?.onReset) { 1686 return A.H.TRUE; 1687 } 1688 return A.H.FALSE; 1689 }, 1690 "func_OnReset": (fn: Pointer): void => { 1691 A.store.Ref(fn, WEBEXT.input.ime.onReset.addListener); 1692 }, 1693 "call_OnReset": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1694 const _ret = WEBEXT.input.ime.onReset.addListener(A.H.get<object>(callback)); 1695 }, 1696 "try_OnReset": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1697 try { 1698 const _ret = WEBEXT.input.ime.onReset.addListener(A.H.get<object>(callback)); 1699 return A.H.TRUE; 1700 } catch (err: any) { 1701 A.store.Ref(errPtr, err); 1702 return A.H.FALSE; 1703 } 1704 }, 1705 "has_OffReset": (): heap.Ref<boolean> => { 1706 if (WEBEXT?.input?.ime?.onReset && "removeListener" in WEBEXT?.input?.ime?.onReset) { 1707 return A.H.TRUE; 1708 } 1709 return A.H.FALSE; 1710 }, 1711 "func_OffReset": (fn: Pointer): void => { 1712 A.store.Ref(fn, WEBEXT.input.ime.onReset.removeListener); 1713 }, 1714 "call_OffReset": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1715 const _ret = WEBEXT.input.ime.onReset.removeListener(A.H.get<object>(callback)); 1716 }, 1717 "try_OffReset": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1718 try { 1719 const _ret = WEBEXT.input.ime.onReset.removeListener(A.H.get<object>(callback)); 1720 return A.H.TRUE; 1721 } catch (err: any) { 1722 A.store.Ref(errPtr, err); 1723 return A.H.FALSE; 1724 } 1725 }, 1726 "has_HasOnReset": (): heap.Ref<boolean> => { 1727 if (WEBEXT?.input?.ime?.onReset && "hasListener" in WEBEXT?.input?.ime?.onReset) { 1728 return A.H.TRUE; 1729 } 1730 return A.H.FALSE; 1731 }, 1732 "func_HasOnReset": (fn: Pointer): void => { 1733 A.store.Ref(fn, WEBEXT.input.ime.onReset.hasListener); 1734 }, 1735 "call_HasOnReset": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1736 const _ret = WEBEXT.input.ime.onReset.hasListener(A.H.get<object>(callback)); 1737 A.store.Bool(retPtr, _ret); 1738 }, 1739 "try_HasOnReset": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 1740 try { 1741 const _ret = WEBEXT.input.ime.onReset.hasListener(A.H.get<object>(callback)); 1742 A.store.Bool(retPtr, _ret); 1743 return A.H.TRUE; 1744 } catch (err: any) { 1745 A.store.Ref(errPtr, err); 1746 return A.H.FALSE; 1747 } 1748 }, 1749 "has_OnSurroundingTextChanged": (): heap.Ref<boolean> => { 1750 if ( 1751 WEBEXT?.input?.ime?.onSurroundingTextChanged && 1752 "addListener" in WEBEXT?.input?.ime?.onSurroundingTextChanged 1753 ) { 1754 return A.H.TRUE; 1755 } 1756 return A.H.FALSE; 1757 }, 1758 "func_OnSurroundingTextChanged": (fn: Pointer): void => { 1759 A.store.Ref(fn, WEBEXT.input.ime.onSurroundingTextChanged.addListener); 1760 }, 1761 "call_OnSurroundingTextChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1762 const _ret = WEBEXT.input.ime.onSurroundingTextChanged.addListener(A.H.get<object>(callback)); 1763 }, 1764 "try_OnSurroundingTextChanged": ( 1765 retPtr: Pointer, 1766 errPtr: Pointer, 1767 callback: heap.Ref<object> 1768 ): heap.Ref<boolean> => { 1769 try { 1770 const _ret = WEBEXT.input.ime.onSurroundingTextChanged.addListener(A.H.get<object>(callback)); 1771 return A.H.TRUE; 1772 } catch (err: any) { 1773 A.store.Ref(errPtr, err); 1774 return A.H.FALSE; 1775 } 1776 }, 1777 "has_OffSurroundingTextChanged": (): heap.Ref<boolean> => { 1778 if ( 1779 WEBEXT?.input?.ime?.onSurroundingTextChanged && 1780 "removeListener" in WEBEXT?.input?.ime?.onSurroundingTextChanged 1781 ) { 1782 return A.H.TRUE; 1783 } 1784 return A.H.FALSE; 1785 }, 1786 "func_OffSurroundingTextChanged": (fn: Pointer): void => { 1787 A.store.Ref(fn, WEBEXT.input.ime.onSurroundingTextChanged.removeListener); 1788 }, 1789 "call_OffSurroundingTextChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1790 const _ret = WEBEXT.input.ime.onSurroundingTextChanged.removeListener(A.H.get<object>(callback)); 1791 }, 1792 "try_OffSurroundingTextChanged": ( 1793 retPtr: Pointer, 1794 errPtr: Pointer, 1795 callback: heap.Ref<object> 1796 ): heap.Ref<boolean> => { 1797 try { 1798 const _ret = WEBEXT.input.ime.onSurroundingTextChanged.removeListener(A.H.get<object>(callback)); 1799 return A.H.TRUE; 1800 } catch (err: any) { 1801 A.store.Ref(errPtr, err); 1802 return A.H.FALSE; 1803 } 1804 }, 1805 "has_HasOnSurroundingTextChanged": (): heap.Ref<boolean> => { 1806 if ( 1807 WEBEXT?.input?.ime?.onSurroundingTextChanged && 1808 "hasListener" in WEBEXT?.input?.ime?.onSurroundingTextChanged 1809 ) { 1810 return A.H.TRUE; 1811 } 1812 return A.H.FALSE; 1813 }, 1814 "func_HasOnSurroundingTextChanged": (fn: Pointer): void => { 1815 A.store.Ref(fn, WEBEXT.input.ime.onSurroundingTextChanged.hasListener); 1816 }, 1817 "call_HasOnSurroundingTextChanged": (retPtr: Pointer, callback: heap.Ref<object>): void => { 1818 const _ret = WEBEXT.input.ime.onSurroundingTextChanged.hasListener(A.H.get<object>(callback)); 1819 A.store.Bool(retPtr, _ret); 1820 }, 1821 "try_HasOnSurroundingTextChanged": ( 1822 retPtr: Pointer, 1823 errPtr: Pointer, 1824 callback: heap.Ref<object> 1825 ): heap.Ref<boolean> => { 1826 try { 1827 const _ret = WEBEXT.input.ime.onSurroundingTextChanged.hasListener(A.H.get<object>(callback)); 1828 A.store.Bool(retPtr, _ret); 1829 return A.H.TRUE; 1830 } catch (err: any) { 1831 A.store.Ref(errPtr, err); 1832 return A.H.FALSE; 1833 } 1834 }, 1835 "has_SendKeyEvents": (): heap.Ref<boolean> => { 1836 if (WEBEXT?.input?.ime && "sendKeyEvents" in WEBEXT?.input?.ime) { 1837 return A.H.TRUE; 1838 } 1839 return A.H.FALSE; 1840 }, 1841 "func_SendKeyEvents": (fn: Pointer): void => { 1842 A.store.Ref(fn, WEBEXT.input.ime.sendKeyEvents); 1843 }, 1844 "call_SendKeyEvents": (retPtr: Pointer, parameters: Pointer): void => { 1845 const parameters_ffi = {}; 1846 1847 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1848 parameters_ffi["keyData"] = A.load.Ref(parameters + 8, undefined); 1849 1850 const _ret = WEBEXT.input.ime.sendKeyEvents(parameters_ffi); 1851 A.store.Ref(retPtr, _ret); 1852 }, 1853 "try_SendKeyEvents": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 1854 try { 1855 const parameters_ffi = {}; 1856 1857 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1858 parameters_ffi["keyData"] = A.load.Ref(parameters + 8, undefined); 1859 1860 const _ret = WEBEXT.input.ime.sendKeyEvents(parameters_ffi); 1861 A.store.Ref(retPtr, _ret); 1862 return A.H.TRUE; 1863 } catch (err: any) { 1864 A.store.Ref(errPtr, err); 1865 return A.H.FALSE; 1866 } 1867 }, 1868 "has_SetAssistiveWindowButtonHighlighted": (): heap.Ref<boolean> => { 1869 if (WEBEXT?.input?.ime && "setAssistiveWindowButtonHighlighted" in WEBEXT?.input?.ime) { 1870 return A.H.TRUE; 1871 } 1872 return A.H.FALSE; 1873 }, 1874 "func_SetAssistiveWindowButtonHighlighted": (fn: Pointer): void => { 1875 A.store.Ref(fn, WEBEXT.input.ime.setAssistiveWindowButtonHighlighted); 1876 }, 1877 "call_SetAssistiveWindowButtonHighlighted": (retPtr: Pointer, parameters: Pointer): void => { 1878 const parameters_ffi = {}; 1879 1880 parameters_ffi["announceString"] = A.load.Ref(parameters + 0, undefined); 1881 parameters_ffi["buttonID"] = A.load.Enum(parameters + 4, ["undo", "addToDictionary"]); 1882 parameters_ffi["contextID"] = A.load.Int64(parameters + 8); 1883 parameters_ffi["highlighted"] = A.load.Bool(parameters + 16); 1884 parameters_ffi["windowType"] = A.load.Enum(parameters + 20, ["undo"]); 1885 1886 const _ret = WEBEXT.input.ime.setAssistiveWindowButtonHighlighted(parameters_ffi); 1887 A.store.Ref(retPtr, _ret); 1888 }, 1889 "try_SetAssistiveWindowButtonHighlighted": ( 1890 retPtr: Pointer, 1891 errPtr: Pointer, 1892 parameters: Pointer 1893 ): heap.Ref<boolean> => { 1894 try { 1895 const parameters_ffi = {}; 1896 1897 parameters_ffi["announceString"] = A.load.Ref(parameters + 0, undefined); 1898 parameters_ffi["buttonID"] = A.load.Enum(parameters + 4, ["undo", "addToDictionary"]); 1899 parameters_ffi["contextID"] = A.load.Int64(parameters + 8); 1900 parameters_ffi["highlighted"] = A.load.Bool(parameters + 16); 1901 parameters_ffi["windowType"] = A.load.Enum(parameters + 20, ["undo"]); 1902 1903 const _ret = WEBEXT.input.ime.setAssistiveWindowButtonHighlighted(parameters_ffi); 1904 A.store.Ref(retPtr, _ret); 1905 return A.H.TRUE; 1906 } catch (err: any) { 1907 A.store.Ref(errPtr, err); 1908 return A.H.FALSE; 1909 } 1910 }, 1911 "has_SetAssistiveWindowProperties": (): heap.Ref<boolean> => { 1912 if (WEBEXT?.input?.ime && "setAssistiveWindowProperties" in WEBEXT?.input?.ime) { 1913 return A.H.TRUE; 1914 } 1915 return A.H.FALSE; 1916 }, 1917 "func_SetAssistiveWindowProperties": (fn: Pointer): void => { 1918 A.store.Ref(fn, WEBEXT.input.ime.setAssistiveWindowProperties); 1919 }, 1920 "call_SetAssistiveWindowProperties": (retPtr: Pointer, parameters: Pointer): void => { 1921 const parameters_ffi = {}; 1922 1923 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1924 if (A.load.Bool(parameters + 8 + 9)) { 1925 parameters_ffi["properties"] = {}; 1926 parameters_ffi["properties"]["announceString"] = A.load.Ref(parameters + 8 + 0, undefined); 1927 parameters_ffi["properties"]["type"] = A.load.Enum(parameters + 8 + 4, ["undo"]); 1928 parameters_ffi["properties"]["visible"] = A.load.Bool(parameters + 8 + 8); 1929 } 1930 1931 const _ret = WEBEXT.input.ime.setAssistiveWindowProperties(parameters_ffi); 1932 A.store.Ref(retPtr, _ret); 1933 }, 1934 "try_SetAssistiveWindowProperties": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 1935 try { 1936 const parameters_ffi = {}; 1937 1938 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 1939 if (A.load.Bool(parameters + 8 + 9)) { 1940 parameters_ffi["properties"] = {}; 1941 parameters_ffi["properties"]["announceString"] = A.load.Ref(parameters + 8 + 0, undefined); 1942 parameters_ffi["properties"]["type"] = A.load.Enum(parameters + 8 + 4, ["undo"]); 1943 parameters_ffi["properties"]["visible"] = A.load.Bool(parameters + 8 + 8); 1944 } 1945 1946 const _ret = WEBEXT.input.ime.setAssistiveWindowProperties(parameters_ffi); 1947 A.store.Ref(retPtr, _ret); 1948 return A.H.TRUE; 1949 } catch (err: any) { 1950 A.store.Ref(errPtr, err); 1951 return A.H.FALSE; 1952 } 1953 }, 1954 "has_SetCandidateWindowProperties": (): heap.Ref<boolean> => { 1955 if (WEBEXT?.input?.ime && "setCandidateWindowProperties" in WEBEXT?.input?.ime) { 1956 return A.H.TRUE; 1957 } 1958 return A.H.FALSE; 1959 }, 1960 "func_SetCandidateWindowProperties": (fn: Pointer): void => { 1961 A.store.Ref(fn, WEBEXT.input.ime.setCandidateWindowProperties); 1962 }, 1963 "call_SetCandidateWindowProperties": (retPtr: Pointer, parameters: Pointer): void => { 1964 const parameters_ffi = {}; 1965 1966 parameters_ffi["engineID"] = A.load.Ref(parameters + 0, undefined); 1967 if (A.load.Bool(parameters + 8 + 55)) { 1968 parameters_ffi["properties"] = {}; 1969 parameters_ffi["properties"]["auxiliaryText"] = A.load.Ref(parameters + 8 + 0, undefined); 1970 if (A.load.Bool(parameters + 8 + 48)) { 1971 parameters_ffi["properties"]["auxiliaryTextVisible"] = A.load.Bool(parameters + 8 + 4); 1972 } 1973 if (A.load.Bool(parameters + 8 + 49)) { 1974 parameters_ffi["properties"]["currentCandidateIndex"] = A.load.Int64(parameters + 8 + 8); 1975 } 1976 if (A.load.Bool(parameters + 8 + 50)) { 1977 parameters_ffi["properties"]["cursorVisible"] = A.load.Bool(parameters + 8 + 16); 1978 } 1979 if (A.load.Bool(parameters + 8 + 51)) { 1980 parameters_ffi["properties"]["pageSize"] = A.load.Int64(parameters + 8 + 24); 1981 } 1982 if (A.load.Bool(parameters + 8 + 52)) { 1983 parameters_ffi["properties"]["totalCandidates"] = A.load.Int64(parameters + 8 + 32); 1984 } 1985 if (A.load.Bool(parameters + 8 + 53)) { 1986 parameters_ffi["properties"]["vertical"] = A.load.Bool(parameters + 8 + 40); 1987 } 1988 if (A.load.Bool(parameters + 8 + 54)) { 1989 parameters_ffi["properties"]["visible"] = A.load.Bool(parameters + 8 + 41); 1990 } 1991 parameters_ffi["properties"]["windowPosition"] = A.load.Enum(parameters + 8 + 44, ["cursor", "composition"]); 1992 } 1993 1994 const _ret = WEBEXT.input.ime.setCandidateWindowProperties(parameters_ffi); 1995 A.store.Ref(retPtr, _ret); 1996 }, 1997 "try_SetCandidateWindowProperties": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 1998 try { 1999 const parameters_ffi = {}; 2000 2001 parameters_ffi["engineID"] = A.load.Ref(parameters + 0, undefined); 2002 if (A.load.Bool(parameters + 8 + 55)) { 2003 parameters_ffi["properties"] = {}; 2004 parameters_ffi["properties"]["auxiliaryText"] = A.load.Ref(parameters + 8 + 0, undefined); 2005 if (A.load.Bool(parameters + 8 + 48)) { 2006 parameters_ffi["properties"]["auxiliaryTextVisible"] = A.load.Bool(parameters + 8 + 4); 2007 } 2008 if (A.load.Bool(parameters + 8 + 49)) { 2009 parameters_ffi["properties"]["currentCandidateIndex"] = A.load.Int64(parameters + 8 + 8); 2010 } 2011 if (A.load.Bool(parameters + 8 + 50)) { 2012 parameters_ffi["properties"]["cursorVisible"] = A.load.Bool(parameters + 8 + 16); 2013 } 2014 if (A.load.Bool(parameters + 8 + 51)) { 2015 parameters_ffi["properties"]["pageSize"] = A.load.Int64(parameters + 8 + 24); 2016 } 2017 if (A.load.Bool(parameters + 8 + 52)) { 2018 parameters_ffi["properties"]["totalCandidates"] = A.load.Int64(parameters + 8 + 32); 2019 } 2020 if (A.load.Bool(parameters + 8 + 53)) { 2021 parameters_ffi["properties"]["vertical"] = A.load.Bool(parameters + 8 + 40); 2022 } 2023 if (A.load.Bool(parameters + 8 + 54)) { 2024 parameters_ffi["properties"]["visible"] = A.load.Bool(parameters + 8 + 41); 2025 } 2026 parameters_ffi["properties"]["windowPosition"] = A.load.Enum(parameters + 8 + 44, ["cursor", "composition"]); 2027 } 2028 2029 const _ret = WEBEXT.input.ime.setCandidateWindowProperties(parameters_ffi); 2030 A.store.Ref(retPtr, _ret); 2031 return A.H.TRUE; 2032 } catch (err: any) { 2033 A.store.Ref(errPtr, err); 2034 return A.H.FALSE; 2035 } 2036 }, 2037 "has_SetCandidates": (): heap.Ref<boolean> => { 2038 if (WEBEXT?.input?.ime && "setCandidates" in WEBEXT?.input?.ime) { 2039 return A.H.TRUE; 2040 } 2041 return A.H.FALSE; 2042 }, 2043 "func_SetCandidates": (fn: Pointer): void => { 2044 A.store.Ref(fn, WEBEXT.input.ime.setCandidates); 2045 }, 2046 "call_SetCandidates": (retPtr: Pointer, parameters: Pointer): void => { 2047 const parameters_ffi = {}; 2048 2049 parameters_ffi["candidates"] = A.load.Ref(parameters + 0, undefined); 2050 parameters_ffi["contextID"] = A.load.Int64(parameters + 8); 2051 2052 const _ret = WEBEXT.input.ime.setCandidates(parameters_ffi); 2053 A.store.Ref(retPtr, _ret); 2054 }, 2055 "try_SetCandidates": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 2056 try { 2057 const parameters_ffi = {}; 2058 2059 parameters_ffi["candidates"] = A.load.Ref(parameters + 0, undefined); 2060 parameters_ffi["contextID"] = A.load.Int64(parameters + 8); 2061 2062 const _ret = WEBEXT.input.ime.setCandidates(parameters_ffi); 2063 A.store.Ref(retPtr, _ret); 2064 return A.H.TRUE; 2065 } catch (err: any) { 2066 A.store.Ref(errPtr, err); 2067 return A.H.FALSE; 2068 } 2069 }, 2070 "has_SetComposition": (): heap.Ref<boolean> => { 2071 if (WEBEXT?.input?.ime && "setComposition" in WEBEXT?.input?.ime) { 2072 return A.H.TRUE; 2073 } 2074 return A.H.FALSE; 2075 }, 2076 "func_SetComposition": (fn: Pointer): void => { 2077 A.store.Ref(fn, WEBEXT.input.ime.setComposition); 2078 }, 2079 "call_SetComposition": (retPtr: Pointer, parameters: Pointer): void => { 2080 const parameters_ffi = {}; 2081 2082 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 2083 parameters_ffi["cursor"] = A.load.Int64(parameters + 8); 2084 parameters_ffi["segments"] = A.load.Ref(parameters + 16, undefined); 2085 if (A.load.Bool(parameters + 44)) { 2086 parameters_ffi["selectionEnd"] = A.load.Int64(parameters + 24); 2087 } 2088 if (A.load.Bool(parameters + 45)) { 2089 parameters_ffi["selectionStart"] = A.load.Int64(parameters + 32); 2090 } 2091 parameters_ffi["text"] = A.load.Ref(parameters + 40, undefined); 2092 2093 const _ret = WEBEXT.input.ime.setComposition(parameters_ffi); 2094 A.store.Ref(retPtr, _ret); 2095 }, 2096 "try_SetComposition": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 2097 try { 2098 const parameters_ffi = {}; 2099 2100 parameters_ffi["contextID"] = A.load.Int64(parameters + 0); 2101 parameters_ffi["cursor"] = A.load.Int64(parameters + 8); 2102 parameters_ffi["segments"] = A.load.Ref(parameters + 16, undefined); 2103 if (A.load.Bool(parameters + 44)) { 2104 parameters_ffi["selectionEnd"] = A.load.Int64(parameters + 24); 2105 } 2106 if (A.load.Bool(parameters + 45)) { 2107 parameters_ffi["selectionStart"] = A.load.Int64(parameters + 32); 2108 } 2109 parameters_ffi["text"] = A.load.Ref(parameters + 40, undefined); 2110 2111 const _ret = WEBEXT.input.ime.setComposition(parameters_ffi); 2112 A.store.Ref(retPtr, _ret); 2113 return A.H.TRUE; 2114 } catch (err: any) { 2115 A.store.Ref(errPtr, err); 2116 return A.H.FALSE; 2117 } 2118 }, 2119 "has_SetCursorPosition": (): heap.Ref<boolean> => { 2120 if (WEBEXT?.input?.ime && "setCursorPosition" in WEBEXT?.input?.ime) { 2121 return A.H.TRUE; 2122 } 2123 return A.H.FALSE; 2124 }, 2125 "func_SetCursorPosition": (fn: Pointer): void => { 2126 A.store.Ref(fn, WEBEXT.input.ime.setCursorPosition); 2127 }, 2128 "call_SetCursorPosition": (retPtr: Pointer, parameters: Pointer): void => { 2129 const parameters_ffi = {}; 2130 2131 parameters_ffi["candidateID"] = A.load.Int64(parameters + 0); 2132 parameters_ffi["contextID"] = A.load.Int64(parameters + 8); 2133 2134 const _ret = WEBEXT.input.ime.setCursorPosition(parameters_ffi); 2135 A.store.Ref(retPtr, _ret); 2136 }, 2137 "try_SetCursorPosition": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 2138 try { 2139 const parameters_ffi = {}; 2140 2141 parameters_ffi["candidateID"] = A.load.Int64(parameters + 0); 2142 parameters_ffi["contextID"] = A.load.Int64(parameters + 8); 2143 2144 const _ret = WEBEXT.input.ime.setCursorPosition(parameters_ffi); 2145 A.store.Ref(retPtr, _ret); 2146 return A.H.TRUE; 2147 } catch (err: any) { 2148 A.store.Ref(errPtr, err); 2149 return A.H.FALSE; 2150 } 2151 }, 2152 "has_SetMenuItems": (): heap.Ref<boolean> => { 2153 if (WEBEXT?.input?.ime && "setMenuItems" in WEBEXT?.input?.ime) { 2154 return A.H.TRUE; 2155 } 2156 return A.H.FALSE; 2157 }, 2158 "func_SetMenuItems": (fn: Pointer): void => { 2159 A.store.Ref(fn, WEBEXT.input.ime.setMenuItems); 2160 }, 2161 "call_SetMenuItems": (retPtr: Pointer, parameters: Pointer): void => { 2162 const parameters_ffi = {}; 2163 2164 parameters_ffi["engineID"] = A.load.Ref(parameters + 0, undefined); 2165 parameters_ffi["items"] = A.load.Ref(parameters + 4, undefined); 2166 2167 const _ret = WEBEXT.input.ime.setMenuItems(parameters_ffi); 2168 A.store.Ref(retPtr, _ret); 2169 }, 2170 "try_SetMenuItems": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 2171 try { 2172 const parameters_ffi = {}; 2173 2174 parameters_ffi["engineID"] = A.load.Ref(parameters + 0, undefined); 2175 parameters_ffi["items"] = A.load.Ref(parameters + 4, undefined); 2176 2177 const _ret = WEBEXT.input.ime.setMenuItems(parameters_ffi); 2178 A.store.Ref(retPtr, _ret); 2179 return A.H.TRUE; 2180 } catch (err: any) { 2181 A.store.Ref(errPtr, err); 2182 return A.H.FALSE; 2183 } 2184 }, 2185 "has_UpdateMenuItems": (): heap.Ref<boolean> => { 2186 if (WEBEXT?.input?.ime && "updateMenuItems" in WEBEXT?.input?.ime) { 2187 return A.H.TRUE; 2188 } 2189 return A.H.FALSE; 2190 }, 2191 "func_UpdateMenuItems": (fn: Pointer): void => { 2192 A.store.Ref(fn, WEBEXT.input.ime.updateMenuItems); 2193 }, 2194 "call_UpdateMenuItems": (retPtr: Pointer, parameters: Pointer): void => { 2195 const parameters_ffi = {}; 2196 2197 parameters_ffi["engineID"] = A.load.Ref(parameters + 0, undefined); 2198 parameters_ffi["items"] = A.load.Ref(parameters + 4, undefined); 2199 2200 const _ret = WEBEXT.input.ime.updateMenuItems(parameters_ffi); 2201 A.store.Ref(retPtr, _ret); 2202 }, 2203 "try_UpdateMenuItems": (retPtr: Pointer, errPtr: Pointer, parameters: Pointer): heap.Ref<boolean> => { 2204 try { 2205 const parameters_ffi = {}; 2206 2207 parameters_ffi["engineID"] = A.load.Ref(parameters + 0, undefined); 2208 parameters_ffi["items"] = A.load.Ref(parameters + 4, undefined); 2209 2210 const _ret = WEBEXT.input.ime.updateMenuItems(parameters_ffi); 2211 A.store.Ref(retPtr, _ret); 2212 return A.H.TRUE; 2213 } catch (err: any) { 2214 A.store.Ref(errPtr, err); 2215 return A.H.FALSE; 2216 } 2217 }, 2218 }; 2219 });