github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/chromewebviewinternal/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/chromewebviewinternal", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_ContextMenuItem": (ptr: Pointer, ref: heap.Ref<any>) => { 8 const x = A.H.get<any>(ref); 9 10 if (typeof x === "undefined") { 11 A.store.Bool(ptr + 12, false); 12 A.store.Int64(ptr + 0, 0); 13 A.store.Ref(ptr + 8, undefined); 14 } else { 15 A.store.Bool(ptr + 12, true); 16 A.store.Int64(ptr + 0, x["commandId"] === undefined ? 0 : (x["commandId"] as number)); 17 A.store.Ref(ptr + 8, x["label"]); 18 } 19 }, 20 "load_ContextMenuItem": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 21 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 22 23 x["commandId"] = A.load.Int64(ptr + 0); 24 x["label"] = A.load.Ref(ptr + 8, undefined); 25 return create === A.H.TRUE ? A.H.push(x) : ref; 26 }, 27 28 "store_ContextMenusCreateArgCreateProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 29 const x = A.H.get<any>(ref); 30 31 if (typeof x === "undefined") { 32 A.store.Bool(ptr + 44, false); 33 A.store.Bool(ptr + 41, false); 34 A.store.Bool(ptr + 0, false); 35 A.store.Ref(ptr + 4, undefined); 36 A.store.Ref(ptr + 8, undefined); 37 A.store.Bool(ptr + 42, false); 38 A.store.Bool(ptr + 12, false); 39 A.store.Ref(ptr + 16, undefined); 40 A.store.Ref(ptr + 20, undefined); 41 A.store.Ref(ptr + 24, undefined); 42 A.store.Ref(ptr + 28, undefined); 43 A.store.Ref(ptr + 32, undefined); 44 A.store.Enum(ptr + 36, -1); 45 A.store.Bool(ptr + 43, false); 46 A.store.Bool(ptr + 40, false); 47 } else { 48 A.store.Bool(ptr + 44, true); 49 A.store.Bool(ptr + 41, "checked" in x ? true : false); 50 A.store.Bool(ptr + 0, x["checked"] ? true : false); 51 A.store.Ref(ptr + 4, x["contexts"]); 52 A.store.Ref(ptr + 8, x["documentUrlPatterns"]); 53 A.store.Bool(ptr + 42, "enabled" in x ? true : false); 54 A.store.Bool(ptr + 12, x["enabled"] ? true : false); 55 A.store.Ref(ptr + 16, x["id"]); 56 A.store.Ref(ptr + 20, x["onclick"]); 57 A.store.Ref(ptr + 24, x["parentId"]); 58 A.store.Ref(ptr + 28, x["targetUrlPatterns"]); 59 A.store.Ref(ptr + 32, x["title"]); 60 A.store.Enum(ptr + 36, ["normal", "checkbox", "radio", "separator"].indexOf(x["type"] as string)); 61 A.store.Bool(ptr + 43, "visible" in x ? true : false); 62 A.store.Bool(ptr + 40, x["visible"] ? true : false); 63 } 64 }, 65 "load_ContextMenusCreateArgCreateProperties": ( 66 ptr: Pointer, 67 create: heap.Ref<boolean>, 68 ref: heap.Ref<any> 69 ): heap.Ref<any> => { 70 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 71 72 if (A.load.Bool(ptr + 41)) { 73 x["checked"] = A.load.Bool(ptr + 0); 74 } else { 75 delete x["checked"]; 76 } 77 x["contexts"] = A.load.Ref(ptr + 4, undefined); 78 x["documentUrlPatterns"] = A.load.Ref(ptr + 8, undefined); 79 if (A.load.Bool(ptr + 42)) { 80 x["enabled"] = A.load.Bool(ptr + 12); 81 } else { 82 delete x["enabled"]; 83 } 84 x["id"] = A.load.Ref(ptr + 16, undefined); 85 x["onclick"] = A.load.Ref(ptr + 20, undefined); 86 x["parentId"] = A.load.Ref(ptr + 24, undefined); 87 x["targetUrlPatterns"] = A.load.Ref(ptr + 28, undefined); 88 x["title"] = A.load.Ref(ptr + 32, undefined); 89 x["type"] = A.load.Enum(ptr + 36, ["normal", "checkbox", "radio", "separator"]); 90 if (A.load.Bool(ptr + 43)) { 91 x["visible"] = A.load.Bool(ptr + 40); 92 } else { 93 delete x["visible"]; 94 } 95 return create === A.H.TRUE ? A.H.push(x) : ref; 96 }, 97 98 "store_ContextMenusUpdateArgUpdateProperties": (ptr: Pointer, ref: heap.Ref<any>) => { 99 const x = A.H.get<any>(ref); 100 101 if (typeof x === "undefined") { 102 A.store.Bool(ptr + 40, false); 103 A.store.Bool(ptr + 37, false); 104 A.store.Bool(ptr + 0, false); 105 A.store.Ref(ptr + 4, undefined); 106 A.store.Ref(ptr + 8, undefined); 107 A.store.Bool(ptr + 38, false); 108 A.store.Bool(ptr + 12, false); 109 A.store.Ref(ptr + 16, undefined); 110 A.store.Ref(ptr + 20, undefined); 111 A.store.Ref(ptr + 24, undefined); 112 A.store.Ref(ptr + 28, undefined); 113 A.store.Enum(ptr + 32, -1); 114 A.store.Bool(ptr + 39, false); 115 A.store.Bool(ptr + 36, false); 116 } else { 117 A.store.Bool(ptr + 40, true); 118 A.store.Bool(ptr + 37, "checked" in x ? true : false); 119 A.store.Bool(ptr + 0, x["checked"] ? true : false); 120 A.store.Ref(ptr + 4, x["contexts"]); 121 A.store.Ref(ptr + 8, x["documentUrlPatterns"]); 122 A.store.Bool(ptr + 38, "enabled" in x ? true : false); 123 A.store.Bool(ptr + 12, x["enabled"] ? true : false); 124 A.store.Ref(ptr + 16, x["onclick"]); 125 A.store.Ref(ptr + 20, x["parentId"]); 126 A.store.Ref(ptr + 24, x["targetUrlPatterns"]); 127 A.store.Ref(ptr + 28, x["title"]); 128 A.store.Enum(ptr + 32, ["normal", "checkbox", "radio", "separator"].indexOf(x["type"] as string)); 129 A.store.Bool(ptr + 39, "visible" in x ? true : false); 130 A.store.Bool(ptr + 36, x["visible"] ? true : false); 131 } 132 }, 133 "load_ContextMenusUpdateArgUpdateProperties": ( 134 ptr: Pointer, 135 create: heap.Ref<boolean>, 136 ref: heap.Ref<any> 137 ): heap.Ref<any> => { 138 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 139 140 if (A.load.Bool(ptr + 37)) { 141 x["checked"] = A.load.Bool(ptr + 0); 142 } else { 143 delete x["checked"]; 144 } 145 x["contexts"] = A.load.Ref(ptr + 4, undefined); 146 x["documentUrlPatterns"] = A.load.Ref(ptr + 8, undefined); 147 if (A.load.Bool(ptr + 38)) { 148 x["enabled"] = A.load.Bool(ptr + 12); 149 } else { 150 delete x["enabled"]; 151 } 152 x["onclick"] = A.load.Ref(ptr + 16, undefined); 153 x["parentId"] = A.load.Ref(ptr + 20, undefined); 154 x["targetUrlPatterns"] = A.load.Ref(ptr + 24, undefined); 155 x["title"] = A.load.Ref(ptr + 28, undefined); 156 x["type"] = A.load.Enum(ptr + 32, ["normal", "checkbox", "radio", "separator"]); 157 if (A.load.Bool(ptr + 39)) { 158 x["visible"] = A.load.Bool(ptr + 36); 159 } else { 160 delete x["visible"]; 161 } 162 return create === A.H.TRUE ? A.H.push(x) : ref; 163 }, 164 165 "store_OnShowArgEvent": (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 + 4, false); 170 A.store.Ref(ptr + 0, undefined); 171 } else { 172 A.store.Bool(ptr + 4, true); 173 A.store.Ref(ptr + 0, x["preventDefault"]); 174 } 175 }, 176 "load_OnShowArgEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 177 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 178 179 x["preventDefault"] = A.load.Ref(ptr + 0, undefined); 180 return create === A.H.TRUE ? A.H.push(x) : ref; 181 }, 182 "has_ContextMenusCreate": (): heap.Ref<boolean> => { 183 if (WEBEXT?.chromeWebViewInternal && "contextMenusCreate" in WEBEXT?.chromeWebViewInternal) { 184 return A.H.TRUE; 185 } 186 return A.H.FALSE; 187 }, 188 "func_ContextMenusCreate": (fn: Pointer): void => { 189 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.contextMenusCreate); 190 }, 191 "call_ContextMenusCreate": ( 192 retPtr: Pointer, 193 instanceId: number, 194 createProperties: Pointer, 195 callback: heap.Ref<object> 196 ): void => { 197 const createProperties_ffi = {}; 198 199 if (A.load.Bool(createProperties + 41)) { 200 createProperties_ffi["checked"] = A.load.Bool(createProperties + 0); 201 } 202 createProperties_ffi["contexts"] = A.load.Ref(createProperties + 4, undefined); 203 createProperties_ffi["documentUrlPatterns"] = A.load.Ref(createProperties + 8, undefined); 204 if (A.load.Bool(createProperties + 42)) { 205 createProperties_ffi["enabled"] = A.load.Bool(createProperties + 12); 206 } 207 createProperties_ffi["id"] = A.load.Ref(createProperties + 16, undefined); 208 createProperties_ffi["onclick"] = A.load.Ref(createProperties + 20, undefined); 209 createProperties_ffi["parentId"] = A.load.Ref(createProperties + 24, undefined); 210 createProperties_ffi["targetUrlPatterns"] = A.load.Ref(createProperties + 28, undefined); 211 createProperties_ffi["title"] = A.load.Ref(createProperties + 32, undefined); 212 createProperties_ffi["type"] = A.load.Enum(createProperties + 36, ["normal", "checkbox", "radio", "separator"]); 213 if (A.load.Bool(createProperties + 43)) { 214 createProperties_ffi["visible"] = A.load.Bool(createProperties + 40); 215 } 216 217 const _ret = WEBEXT.chromeWebViewInternal.contextMenusCreate( 218 instanceId, 219 createProperties_ffi, 220 A.H.get<object>(callback) 221 ); 222 A.store.Ref(retPtr, _ret); 223 }, 224 "try_ContextMenusCreate": ( 225 retPtr: Pointer, 226 errPtr: Pointer, 227 instanceId: number, 228 createProperties: Pointer, 229 callback: heap.Ref<object> 230 ): heap.Ref<boolean> => { 231 try { 232 const createProperties_ffi = {}; 233 234 if (A.load.Bool(createProperties + 41)) { 235 createProperties_ffi["checked"] = A.load.Bool(createProperties + 0); 236 } 237 createProperties_ffi["contexts"] = A.load.Ref(createProperties + 4, undefined); 238 createProperties_ffi["documentUrlPatterns"] = A.load.Ref(createProperties + 8, undefined); 239 if (A.load.Bool(createProperties + 42)) { 240 createProperties_ffi["enabled"] = A.load.Bool(createProperties + 12); 241 } 242 createProperties_ffi["id"] = A.load.Ref(createProperties + 16, undefined); 243 createProperties_ffi["onclick"] = A.load.Ref(createProperties + 20, undefined); 244 createProperties_ffi["parentId"] = A.load.Ref(createProperties + 24, undefined); 245 createProperties_ffi["targetUrlPatterns"] = A.load.Ref(createProperties + 28, undefined); 246 createProperties_ffi["title"] = A.load.Ref(createProperties + 32, undefined); 247 createProperties_ffi["type"] = A.load.Enum(createProperties + 36, ["normal", "checkbox", "radio", "separator"]); 248 if (A.load.Bool(createProperties + 43)) { 249 createProperties_ffi["visible"] = A.load.Bool(createProperties + 40); 250 } 251 252 const _ret = WEBEXT.chromeWebViewInternal.contextMenusCreate( 253 instanceId, 254 createProperties_ffi, 255 A.H.get<object>(callback) 256 ); 257 A.store.Ref(retPtr, _ret); 258 return A.H.TRUE; 259 } catch (err: any) { 260 A.store.Ref(errPtr, err); 261 return A.H.FALSE; 262 } 263 }, 264 "has_ContextMenusRemove": (): heap.Ref<boolean> => { 265 if (WEBEXT?.chromeWebViewInternal && "contextMenusRemove" in WEBEXT?.chromeWebViewInternal) { 266 return A.H.TRUE; 267 } 268 return A.H.FALSE; 269 }, 270 "func_ContextMenusRemove": (fn: Pointer): void => { 271 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.contextMenusRemove); 272 }, 273 "call_ContextMenusRemove": ( 274 retPtr: Pointer, 275 instanceId: number, 276 menuItemId: heap.Ref<any>, 277 callback: heap.Ref<object> 278 ): void => { 279 const _ret = WEBEXT.chromeWebViewInternal.contextMenusRemove( 280 instanceId, 281 A.H.get<any>(menuItemId), 282 A.H.get<object>(callback) 283 ); 284 }, 285 "try_ContextMenusRemove": ( 286 retPtr: Pointer, 287 errPtr: Pointer, 288 instanceId: number, 289 menuItemId: heap.Ref<any>, 290 callback: heap.Ref<object> 291 ): heap.Ref<boolean> => { 292 try { 293 const _ret = WEBEXT.chromeWebViewInternal.contextMenusRemove( 294 instanceId, 295 A.H.get<any>(menuItemId), 296 A.H.get<object>(callback) 297 ); 298 return A.H.TRUE; 299 } catch (err: any) { 300 A.store.Ref(errPtr, err); 301 return A.H.FALSE; 302 } 303 }, 304 "has_ContextMenusRemoveAll": (): heap.Ref<boolean> => { 305 if (WEBEXT?.chromeWebViewInternal && "contextMenusRemoveAll" in WEBEXT?.chromeWebViewInternal) { 306 return A.H.TRUE; 307 } 308 return A.H.FALSE; 309 }, 310 "func_ContextMenusRemoveAll": (fn: Pointer): void => { 311 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.contextMenusRemoveAll); 312 }, 313 "call_ContextMenusRemoveAll": (retPtr: Pointer, instanceId: number, callback: heap.Ref<object>): void => { 314 const _ret = WEBEXT.chromeWebViewInternal.contextMenusRemoveAll(instanceId, A.H.get<object>(callback)); 315 }, 316 "try_ContextMenusRemoveAll": ( 317 retPtr: Pointer, 318 errPtr: Pointer, 319 instanceId: number, 320 callback: heap.Ref<object> 321 ): heap.Ref<boolean> => { 322 try { 323 const _ret = WEBEXT.chromeWebViewInternal.contextMenusRemoveAll(instanceId, A.H.get<object>(callback)); 324 return A.H.TRUE; 325 } catch (err: any) { 326 A.store.Ref(errPtr, err); 327 return A.H.FALSE; 328 } 329 }, 330 "has_ContextMenusUpdate": (): heap.Ref<boolean> => { 331 if (WEBEXT?.chromeWebViewInternal && "contextMenusUpdate" in WEBEXT?.chromeWebViewInternal) { 332 return A.H.TRUE; 333 } 334 return A.H.FALSE; 335 }, 336 "func_ContextMenusUpdate": (fn: Pointer): void => { 337 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.contextMenusUpdate); 338 }, 339 "call_ContextMenusUpdate": ( 340 retPtr: Pointer, 341 instanceId: number, 342 id: heap.Ref<any>, 343 updateProperties: Pointer, 344 callback: heap.Ref<object> 345 ): void => { 346 const updateProperties_ffi = {}; 347 348 if (A.load.Bool(updateProperties + 37)) { 349 updateProperties_ffi["checked"] = A.load.Bool(updateProperties + 0); 350 } 351 updateProperties_ffi["contexts"] = A.load.Ref(updateProperties + 4, undefined); 352 updateProperties_ffi["documentUrlPatterns"] = A.load.Ref(updateProperties + 8, undefined); 353 if (A.load.Bool(updateProperties + 38)) { 354 updateProperties_ffi["enabled"] = A.load.Bool(updateProperties + 12); 355 } 356 updateProperties_ffi["onclick"] = A.load.Ref(updateProperties + 16, undefined); 357 updateProperties_ffi["parentId"] = A.load.Ref(updateProperties + 20, undefined); 358 updateProperties_ffi["targetUrlPatterns"] = A.load.Ref(updateProperties + 24, undefined); 359 updateProperties_ffi["title"] = A.load.Ref(updateProperties + 28, undefined); 360 updateProperties_ffi["type"] = A.load.Enum(updateProperties + 32, ["normal", "checkbox", "radio", "separator"]); 361 if (A.load.Bool(updateProperties + 39)) { 362 updateProperties_ffi["visible"] = A.load.Bool(updateProperties + 36); 363 } 364 365 const _ret = WEBEXT.chromeWebViewInternal.contextMenusUpdate( 366 instanceId, 367 A.H.get<any>(id), 368 updateProperties_ffi, 369 A.H.get<object>(callback) 370 ); 371 }, 372 "try_ContextMenusUpdate": ( 373 retPtr: Pointer, 374 errPtr: Pointer, 375 instanceId: number, 376 id: heap.Ref<any>, 377 updateProperties: Pointer, 378 callback: heap.Ref<object> 379 ): heap.Ref<boolean> => { 380 try { 381 const updateProperties_ffi = {}; 382 383 if (A.load.Bool(updateProperties + 37)) { 384 updateProperties_ffi["checked"] = A.load.Bool(updateProperties + 0); 385 } 386 updateProperties_ffi["contexts"] = A.load.Ref(updateProperties + 4, undefined); 387 updateProperties_ffi["documentUrlPatterns"] = A.load.Ref(updateProperties + 8, undefined); 388 if (A.load.Bool(updateProperties + 38)) { 389 updateProperties_ffi["enabled"] = A.load.Bool(updateProperties + 12); 390 } 391 updateProperties_ffi["onclick"] = A.load.Ref(updateProperties + 16, undefined); 392 updateProperties_ffi["parentId"] = A.load.Ref(updateProperties + 20, undefined); 393 updateProperties_ffi["targetUrlPatterns"] = A.load.Ref(updateProperties + 24, undefined); 394 updateProperties_ffi["title"] = A.load.Ref(updateProperties + 28, undefined); 395 updateProperties_ffi["type"] = A.load.Enum(updateProperties + 32, ["normal", "checkbox", "radio", "separator"]); 396 if (A.load.Bool(updateProperties + 39)) { 397 updateProperties_ffi["visible"] = A.load.Bool(updateProperties + 36); 398 } 399 400 const _ret = WEBEXT.chromeWebViewInternal.contextMenusUpdate( 401 instanceId, 402 A.H.get<any>(id), 403 updateProperties_ffi, 404 A.H.get<object>(callback) 405 ); 406 return A.H.TRUE; 407 } catch (err: any) { 408 A.store.Ref(errPtr, err); 409 return A.H.FALSE; 410 } 411 }, 412 "has_OnClicked": (): heap.Ref<boolean> => { 413 if (WEBEXT?.chromeWebViewInternal?.onClicked && "addListener" in WEBEXT?.chromeWebViewInternal?.onClicked) { 414 return A.H.TRUE; 415 } 416 return A.H.FALSE; 417 }, 418 "func_OnClicked": (fn: Pointer): void => { 419 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.onClicked.addListener); 420 }, 421 "call_OnClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 422 const _ret = WEBEXT.chromeWebViewInternal.onClicked.addListener(A.H.get<object>(callback)); 423 }, 424 "try_OnClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 425 try { 426 const _ret = WEBEXT.chromeWebViewInternal.onClicked.addListener(A.H.get<object>(callback)); 427 return A.H.TRUE; 428 } catch (err: any) { 429 A.store.Ref(errPtr, err); 430 return A.H.FALSE; 431 } 432 }, 433 "has_OffClicked": (): heap.Ref<boolean> => { 434 if (WEBEXT?.chromeWebViewInternal?.onClicked && "removeListener" in WEBEXT?.chromeWebViewInternal?.onClicked) { 435 return A.H.TRUE; 436 } 437 return A.H.FALSE; 438 }, 439 "func_OffClicked": (fn: Pointer): void => { 440 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.onClicked.removeListener); 441 }, 442 "call_OffClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 443 const _ret = WEBEXT.chromeWebViewInternal.onClicked.removeListener(A.H.get<object>(callback)); 444 }, 445 "try_OffClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 446 try { 447 const _ret = WEBEXT.chromeWebViewInternal.onClicked.removeListener(A.H.get<object>(callback)); 448 return A.H.TRUE; 449 } catch (err: any) { 450 A.store.Ref(errPtr, err); 451 return A.H.FALSE; 452 } 453 }, 454 "has_HasOnClicked": (): heap.Ref<boolean> => { 455 if (WEBEXT?.chromeWebViewInternal?.onClicked && "hasListener" in WEBEXT?.chromeWebViewInternal?.onClicked) { 456 return A.H.TRUE; 457 } 458 return A.H.FALSE; 459 }, 460 "func_HasOnClicked": (fn: Pointer): void => { 461 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.onClicked.hasListener); 462 }, 463 "call_HasOnClicked": (retPtr: Pointer, callback: heap.Ref<object>): void => { 464 const _ret = WEBEXT.chromeWebViewInternal.onClicked.hasListener(A.H.get<object>(callback)); 465 A.store.Bool(retPtr, _ret); 466 }, 467 "try_HasOnClicked": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 468 try { 469 const _ret = WEBEXT.chromeWebViewInternal.onClicked.hasListener(A.H.get<object>(callback)); 470 A.store.Bool(retPtr, _ret); 471 return A.H.TRUE; 472 } catch (err: any) { 473 A.store.Ref(errPtr, err); 474 return A.H.FALSE; 475 } 476 }, 477 "has_OnShow": (): heap.Ref<boolean> => { 478 if (WEBEXT?.chromeWebViewInternal?.onShow && "addListener" in WEBEXT?.chromeWebViewInternal?.onShow) { 479 return A.H.TRUE; 480 } 481 return A.H.FALSE; 482 }, 483 "func_OnShow": (fn: Pointer): void => { 484 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.onShow.addListener); 485 }, 486 "call_OnShow": (retPtr: Pointer, callback: heap.Ref<object>): void => { 487 const _ret = WEBEXT.chromeWebViewInternal.onShow.addListener(A.H.get<object>(callback)); 488 }, 489 "try_OnShow": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 490 try { 491 const _ret = WEBEXT.chromeWebViewInternal.onShow.addListener(A.H.get<object>(callback)); 492 return A.H.TRUE; 493 } catch (err: any) { 494 A.store.Ref(errPtr, err); 495 return A.H.FALSE; 496 } 497 }, 498 "has_OffShow": (): heap.Ref<boolean> => { 499 if (WEBEXT?.chromeWebViewInternal?.onShow && "removeListener" in WEBEXT?.chromeWebViewInternal?.onShow) { 500 return A.H.TRUE; 501 } 502 return A.H.FALSE; 503 }, 504 "func_OffShow": (fn: Pointer): void => { 505 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.onShow.removeListener); 506 }, 507 "call_OffShow": (retPtr: Pointer, callback: heap.Ref<object>): void => { 508 const _ret = WEBEXT.chromeWebViewInternal.onShow.removeListener(A.H.get<object>(callback)); 509 }, 510 "try_OffShow": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 511 try { 512 const _ret = WEBEXT.chromeWebViewInternal.onShow.removeListener(A.H.get<object>(callback)); 513 return A.H.TRUE; 514 } catch (err: any) { 515 A.store.Ref(errPtr, err); 516 return A.H.FALSE; 517 } 518 }, 519 "has_HasOnShow": (): heap.Ref<boolean> => { 520 if (WEBEXT?.chromeWebViewInternal?.onShow && "hasListener" in WEBEXT?.chromeWebViewInternal?.onShow) { 521 return A.H.TRUE; 522 } 523 return A.H.FALSE; 524 }, 525 "func_HasOnShow": (fn: Pointer): void => { 526 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.onShow.hasListener); 527 }, 528 "call_HasOnShow": (retPtr: Pointer, callback: heap.Ref<object>): void => { 529 const _ret = WEBEXT.chromeWebViewInternal.onShow.hasListener(A.H.get<object>(callback)); 530 A.store.Bool(retPtr, _ret); 531 }, 532 "try_HasOnShow": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 533 try { 534 const _ret = WEBEXT.chromeWebViewInternal.onShow.hasListener(A.H.get<object>(callback)); 535 A.store.Bool(retPtr, _ret); 536 return A.H.TRUE; 537 } catch (err: any) { 538 A.store.Ref(errPtr, err); 539 return A.H.FALSE; 540 } 541 }, 542 "has_ShowContextMenu": (): heap.Ref<boolean> => { 543 if (WEBEXT?.chromeWebViewInternal && "showContextMenu" in WEBEXT?.chromeWebViewInternal) { 544 return A.H.TRUE; 545 } 546 return A.H.FALSE; 547 }, 548 "func_ShowContextMenu": (fn: Pointer): void => { 549 A.store.Ref(fn, WEBEXT.chromeWebViewInternal.showContextMenu); 550 }, 551 "call_ShowContextMenu": ( 552 retPtr: Pointer, 553 instanceId: number, 554 requestId: number, 555 itemsToShow: heap.Ref<object> 556 ): void => { 557 const _ret = WEBEXT.chromeWebViewInternal.showContextMenu(instanceId, requestId, A.H.get<object>(itemsToShow)); 558 }, 559 "try_ShowContextMenu": ( 560 retPtr: Pointer, 561 errPtr: Pointer, 562 instanceId: number, 563 requestId: number, 564 itemsToShow: heap.Ref<object> 565 ): heap.Ref<boolean> => { 566 try { 567 const _ret = WEBEXT.chromeWebViewInternal.showContextMenu(instanceId, requestId, A.H.get<object>(itemsToShow)); 568 return A.H.TRUE; 569 } catch (err: any) { 570 A.store.Ref(errPtr, err); 571 return A.H.FALSE; 572 } 573 }, 574 }; 575 });