lua.lyx

   1 #LyX 2.0 created this file. For more info see http://www.lyx.org/
   2 \lyxformat 413
   3 \begin_document
   4 \begin_header
   5 \textclass article
   6 \use_default_options true
   7 \maintain_unincluded_children false
   8 \language english
   9 \language_package default
  10 \inputencoding auto
  11 \fontencoding global
  12 \font_roman default
  13 \font_sans default
  14 \font_typewriter default
  15 \font_default_family default
  16 \use_non_tex_fonts false
  17 \font_sc false
  18 \font_osf false
  19 \font_sf_scale 100
  20 \font_tt_scale 100
  21
  22 \graphics default
  23 \default_output_format default
  24 \output_sync 0
  25 \bibtex_command default
  26 \index_command default
  27 \paperfontsize default
  28 \spacing single
  29 \use_hyperref true
  30 \pdf_bookmarks true
  31 \pdf_bookmarksnumbered false
  32 \pdf_bookmarksopen false
  33 \pdf_bookmarksopenlevel 1
  34 \pdf_breaklinks false
  35 \pdf_pdfborder false
  36 \pdf_colorlinks false
  37 \pdf_backref false
  38 \pdf_pdfusetitle true
  39 \papersize a4paper
  40 \use_geometry true
  41 \use_amsmath 1
  42 \use_esint 1
  43 \use_mhchem 1
  44 \use_mathdots 1
  45 \cite_engine basic
  46 \use_bibtopic false
  47 \use_indices false
  48 \paperorientation portrait
  49 \suppress_date false
  50 \use_refstyle 1
  51 \index Hakusana
  52 \shortcut idx
  53 \color #008000
  54 \end_index
  55 \leftmargin 2cm
  56 \topmargin 2cm
  57 \rightmargin 1cm
  58 \bottommargin 2cm
  59 \headheight 1cm
  60 \headsep 1cm
  61 \footskip 1cm
  62 \secnumdepth 3
  63 \tocdepth 3
  64 \paragraph_separation indent
  65 \paragraph_indentation default
  66 \quotes_language english
  67 \papercolumns 1
  68 \papersides 1
  69 \paperpagestyle default
  70 \tracking_changes false
  71 \output_changes false
  72 \html_math_output 0
  73 \html_css_as_file 0
  74 \html_be_strict false
  75 \end_header
  76
  77 \begin_body
  78
  79 \begin_layout Title
  80 lsnes Lua functions reference
  81 \end_layout
  82
  83 \begin_layout Section
  84 Table of contents
  85 \end_layout
  86
  87 \begin_layout Standard
  88 \begin_inset CommandInset toc
  89 LatexCommand tableofcontents
  90
  91 \end_inset
  92
  93
  94 \end_layout
  95
  96 \begin_layout Standard
  97 \begin_inset Newpage pagebreak
  98 \end_inset
  99
 100
 101 \end_layout
 102
 103 \begin_layout Section
 104 Special tokens
 105 \end_layout
 106
 107 \begin_layout Standard
 108 These tokens are special, and are expanded while the script is being loaded
 109 \end_layout
 110
 111 \begin_layout Subsection
 112 @@LUA_SCRIPT_FILENAME@@
 113 \end_layout
 114
 115 \begin_layout Standard
 116 Expanded to string token containing path and filename of this Lua script.
 117  Handy for referencing other lua scripts or resources that are relative
 118  to this Lua script.
 119 \end_layout
 120
 121 \begin_layout Standard
 122 In practicular, this is suitable to be passed as base argument of various
 123  functions like loadfile, dofile, resolve_filename, gui.bitmap_load, gui.bitmap_lo
 124 ad_png and gui.bitmap_load_pal.
 125 \end_layout
 126
 127 \begin_layout Section
 128 Global
 129 \end_layout
 130
 131 \begin_layout Subsection
 132 print: Print values to console
 133 \end_layout
 134
 135 \begin_layout Itemize
 136 Syntax: none print(value...
 137  values)
 138 \end_layout
 139
 140 \begin_layout Standard
 141 Prints specified values to console.
 142  Can print any Lua type at least enough to identify the type and instance.
 143 \end_layout
 144
 145 \begin_layout Subsection
 146 tostringx: Format a value to string
 147 \end_layout
 148
 149 \begin_layout Itemize
 150 Syntax: string tostringx(value val)
 151 \end_layout
 152
 153 \begin_layout Standard
 154 Formats value <val> like print would, and returns the result as a string.
 155 \end_layout
 156
 157 \begin_layout Subsection
 158 exec: Execute lsnes commands
 159 \end_layout
 160
 161 \begin_layout Itemize
 162 Syntax: none exec(string cmd)
 163 \end_layout
 164
 165 \begin_layout Standard
 166 Execute lsnes command <cmd>.
 167 \end_layout
 168
 169 \begin_layout Subsection
 170 utime: Get current time
 171 \end_layout
 172
 173 \begin_layout Itemize
 174 Syntax: (number,number) utime()
 175 \end_layout
 176
 177 \begin_layout Standard
 178 Returns two numbers.
 179  First is time since some epoch in seconds, the second is microseconds mod
 180  10^6 since that epoch.
 181 \end_layout
 182
 183 \begin_layout Subsection
 184 emulator_ready: Check if emulator has been fully initialized
 185 \end_layout
 186
 187 \begin_layout Itemize
 188 Syntax: boolean emulator_ready()
 189 \end_layout
 190
 191 \begin_layout Standard
 192 Returns true if emulator has finished booting, false if not (on_startup()
 193  will be issued later).
 194 \end_layout
 195
 196 \begin_layout Subsection
 197 set_idle_timeout: Run function after timeout when emulator is idle
 198 \end_layout
 199
 200 \begin_layout Itemize
 201 Syntax: none set_idle_timeout(number timeout)
 202 \end_layout
 203
 204 \begin_layout Standard
 205 Set number of microseconds to block idle for.
 206  After this timeout has expired, on_idle() will be called once.
 207 \end_layout
 208
 209 \begin_layout Subsection
 210 set_timer_timeout: Run function after timeout.
 211 \end_layout
 212
 213 \begin_layout Itemize
 214 Syntax: none set_timer_timeout(number timeout)
 215 \end_layout
 216
 217 \begin_layout Standard
 218 Set number of microseconds to block timer for.
 219  After this timeout has expired, on_timer() will be called once.
 220 \end_layout
 221
 222 \begin_layout Subsection
 223 bus_address: Look up address in system bus.
 224 \end_layout
 225
 226 \begin_layout Itemize
 227 Syntax: none bus_address(number bus_addr)
 228 \end_layout
 229
 230 \begin_layout Standard
 231 Returns virtual address corresponding to specified address on system bus.
 232 \end_layout
 233
 234 \begin_layout Subsection
 235 loopwrapper: Convert loop into callable function
 236 \end_layout
 237
 238 \begin_layout Itemize
 239 Syntax: function loopwrapper(function fun, ...)
 240 \end_layout
 241
 242 \begin_layout Standard
 243 Calls function <fun> with function and specified arguments.
 244  The function passed suspends execution until the function returned is called.
 245  Handy for linear flow control among multiple invocations of a hook.
 246  Example code:
 247 \end_layout
 248
 249 \begin_layout LyX-Code
 250 on_paint = loopwrapper(function(wait)
 251 \end_layout
 252
 253 \begin_deeper
 254 \begin_layout LyX-Code
 255 while true do
 256 \end_layout
 257
 258 \begin_deeper
 259 \begin_layout LyX-Code
 260 gui.text(0, 0,
 261 \begin_inset Quotes eld
 262 \end_inset
 263
 264 Test!
 265 \begin_inset Quotes erd
 266 \end_inset
 267
 268 );
 269 \end_layout
 270
 271 \begin_layout LyX-Code
 272 wait();
 273 \end_layout
 274
 275 \end_deeper
 276 \begin_layout LyX-Code
 277 end
 278 \end_layout
 279
 280 \end_deeper
 281 \begin_layout LyX-Code
 282 end);
 283 \end_layout
 284
 285 \begin_layout Subsection
 286 list_bindings: List keybindings
 287 \end_layout
 288
 289 \begin_layout Itemize
 290 Syntax: table list_bindings([string cmd])
 291 \end_layout
 292
 293 \begin_layout Standard
 294 Get table of all keybindings, indexed by keyspec (modifiers|mask/key).
 295  If <cmd> is specified, the table is limited to that command.
 296  Also searches for controller keys.
 297 \end_layout
 298
 299 \begin_layout Subsection
 300 get_alias: Get expansion of alias
 301 \end_layout
 302
 303 \begin_layout Itemize
 304 Syntax: string get_alias(string aname)
 305 \end_layout
 306
 307 \begin_layout Standard
 308 Get expansion of given alias <aname>.
 309 \end_layout
 310
 311 \begin_layout Subsection
 312 set_alias: Set expansion of alias
 313 \end_layout
 314
 315 \begin_layout Itemize
 316 Syntax: none set_alias(string aname, string value)
 317 \end_layout
 318
 319 \begin_layout Standard
 320 Set expansion of given alias.
 321 \end_layout
 322
 323 \begin_layout Subsection
 324 create_ibind: Create invese binding
 325 \end_layout
 326
 327 \begin_layout Itemize
 328 Syntax: INVERSEBIND create_ibind(string name, string cmd)
 329 \end_layout
 330
 331 \begin_layout Standard
 332 Return object representing inverse binding with specified name <name> and
 333  specified command <cmd>.
 334 \end_layout
 335
 336 \begin_layout Itemize
 337 Note: To create press/release commands, use aliases +foo and -foo .
 338 \end_layout
 339
 340 \begin_layout Itemize
 341 Note: Keep the returned object around.
 342 \end_layout
 343
 344 \begin_layout Subsection
 345 create_command: Create a command
 346 \end_layout
 347
 348 \begin_layout Itemize
 349 Syntax: COMMANDBIND create_commmand(string name, function a)
 350 \end_layout
 351
 352 \begin_layout Itemize
 353 Syntax: COMMANDBIND create_commmand(string name, function a, function b)
 354 \end_layout
 355
 356 \begin_layout Standard
 357 Return object representing a command (pair).
 358 \end_layout
 359
 360 \begin_layout Itemize
 361 If only one function is specied, the command is level-sensitive, <a> is
 362  callback.
 363 \end_layout
 364
 365 \begin_layout Itemize
 366 If <b> is function, the function is edge-sensitive, <a> is positive edge
 367  callback and <b> is negative edge callback.
 368 \end_layout
 369
 370 \begin_layout Itemize
 371 All callbacks get single argument: The parameters passed.
 372 \end_layout
 373
 374 \begin_layout Itemize
 375 Keep the returned object around.
 376 \end_layout
 377
 378 \begin_layout Subsection
 379 loadfile: Load Lua script
 380 \end_layout
 381
 382 \begin_layout Itemize
 383 Syntax: function loadfile(string filename[, string base])
 384 \end_layout
 385
 386 \begin_layout Standard
 387 Load lua script from <filename>, resolved relative to <base> (if empty,
 388  current directory).
 389 \end_layout
 390
 391 \begin_layout Subsection
 392 dofile: Execute Lua script
 393 \end_layout
 394
 395 \begin_layout Itemize
 396 Syntax: function dofile(string filename[, string base])
 397 \end_layout
 398
 399 \begin_layout Standard
 400 Execute lua script from <filename>, resolved relative to <base> (if empty,
 401  current directory) and return all return values.
 402 \end_layout
 403
 404 \begin_layout Subsection
 405 open_file: Open a stream
 406 \end_layout
 407
 408 \begin_layout Itemize
 409 Syntax: FILEREADER open_file(string filename[, string base])
 410 \end_layout
 411
 412 \begin_layout Standard
 413 Open file <filename>, resolved relative to <base> (if empty, current directory)
 414  and return a handle.
 415 \end_layout
 416
 417 \begin_layout Subsection
 418 FILEREADER(): Read line/bytes from stream
 419 \end_layout
 420
 421 \begin_layout Itemize
 422 Syntax: string/nil FILEREADER()
 423 \end_layout
 424
 425 \begin_layout Itemize
 426 Syntax: string/nil FILEREADER(number bytes)
 427 \end_layout
 428
 429 \begin_layout Standard
 430 Reads next line or <bytes> bytes from specified file handle.
 431  On EOF, nil is returned.
 432 \end_layout
 433
 434 \begin_layout Itemize
 435 Note: The line-oriented variant reads in text mode, so CR at end of line
 436  is stripped.
 437 \end_layout
 438
 439 \begin_layout Subsection
 440 FILEREADER:lines: Iterator to read all lines
 441 \end_layout
 442
 443 \begin_layout Itemize
 444 Syntax: for line in <foo>:lines() do ...
 445  end
 446 \end_layout
 447
 448 \begin_layout Standard
 449 Iterator for reading all lines of <foo> in a loop.
 450 \end_layout
 451
 452 \begin_layout Subsection
 453 resolve_filename: Resolve name of file relative to another
 454 \end_layout
 455
 456 \begin_layout Itemize
 457 Syntax: string resolve_file(string filename, string base)
 458 \end_layout
 459
 460 \begin_layout Standard
 461 Resolve name of file <filename> relative to <base> and return the result.
 462 \end_layout
 463
 464 \begin_layout Standard
 465 \begin_inset Newpage pagebreak
 466 \end_inset
 467
 468
 469 \end_layout
 470
 471 \begin_layout Section
 472 Table bit:
 473 \end_layout
 474
 475 \begin_layout Standard
 476 Bitwise logical functions and related.
 477 \end_layout
 478
 479 \begin_layout Subsection
 480 bit.none/bit.bnot: Bitwise none or NOT function
 481 \end_layout
 482
 483 \begin_layout Itemize
 484 Syntax: number bit.none(number...)
 485 \end_layout
 486
 487 \begin_layout Itemize
 488 Syntax: number bit.bnot(number...)
 489 \end_layout
 490
 491 \begin_layout Standard
 492 48-bit bitwise NOT / NONE function (set bits that are set in none of the
 493  arguments).
 494 \end_layout
 495
 496 \begin_layout Subsection
 497 bit.any/bit.bor: Bitwise any or OR function
 498 \end_layout
 499
 500 \begin_layout Itemize
 501 Syntax: number bit.any(number...)
 502 \end_layout
 503
 504 \begin_layout Itemize
 505 Syntax: number bit.bor(number...)
 506 \end_layout
 507
 508 \begin_layout Standard
 509 48-bit bitwise OR / ANY function (set bits that are set in any of the arguments).
 510 \end_layout
 511
 512 \begin_layout Subsection
 513 bit.all/bit.band: Bitwise all or AND function
 514 \end_layout
 515
 516 \begin_layout Itemize
 517 Syntax: number bit.all(number...)
 518 \end_layout
 519
 520 \begin_layout Itemize
 521 Syntax: number bit.band(number...)
 522 \end_layout
 523
 524 \begin_layout Standard
 525 48-bit bitwise AND / ALL function (set bits that are set in all of the arguments
 526 ).
 527 \end_layout
 528
 529 \begin_layout Subsection
 530 bit.parity/bit.bxor: Bitwise parity or XOR function
 531 \end_layout
 532
 533 \begin_layout Itemize
 534 Syntax: number bit.parity(number...)
 535 \end_layout
 536
 537 \begin_layout Itemize
 538 Syntax: number bit.bxor(number...)
 539 \end_layout
 540
 541 \begin_layout Standard
 542 48-bit bitwise XOR / PARITY function (set bits that are set in odd number
 543  of the arguments).
 544 \end_layout
 545
 546 \begin_layout Subsection
 547 bit.lrotate: Rotate a number left
 548 \end_layout
 549
 550 \begin_layout Itemize
 551 Syntax: number bit.lrotate(number base[, number amount[, number bits]])
 552 \end_layout
 553
 554 \begin_layout Standard
 555 Rotate <bits>-bit (max 48, default 48) number <base> left by <amount> (default
 556  1) places.
 557 \end_layout
 558
 559 \begin_layout Subsection
 560 bit.rrotate: Rotate a number right
 561 \end_layout
 562
 563 \begin_layout Itemize
 564 Syntax: number bit.rrotate(number base[, number amount[, number bits]])
 565 \end_layout
 566
 567 \begin_layout Standard
 568 Rotate <bits>-bit (max 48, default 48) number <base> right by <amount> (default
 569  1) places.
 570 \end_layout
 571
 572 \begin_layout Subsection
 573 bit.lshift: Shift a number left
 574 \end_layout
 575
 576 \begin_layout Itemize
 577 Syntax: number bit.lshift(number base[, number amount[, number bits]])
 578 \end_layout
 579
 580 \begin_layout Standard
 581 Shift <bits>-bit (max 48, default 48) number <base> left by <amount> (default
 582  1) places.
 583  The new bits are filled with zeroes.
 584 \end_layout
 585
 586 \begin_layout Subsection
 587 bit.lrshift: Shift a number right (logical)
 588 \end_layout
 589
 590 \begin_layout Itemize
 591 Syntax: number bit.lrshift(number base[, number amount[, number bits]])
 592 \end_layout
 593
 594 \begin_layout Standard
 595 Shift <bits>-bit (max 48, default 48) number <base> logically right by <amount>
 596  (default 1) places.
 597  The new bits are filled with zeroes.
 598 \end_layout
 599
 600 \begin_layout Subsection
 601 bit.arshift: Shift a number right (arithmetic)
 602 \end_layout
 603
 604 \begin_layout Itemize
 605 Syntax: number bit.arshift(number base[, number amount[, number bits]])
 606 \end_layout
 607
 608 \begin_layout Standard
 609 Shift <bits>-bit (max 48, default 48) number <base> logically right by <amount>
 610  (default 1) places.
 611  The new bits are shifted in with copy of the high bit.
 612 \end_layout
 613
 614 \begin_layout Subsection
 615 bit.extract: Extract/shuffle bits from number
 616 \end_layout
 617
 618 \begin_layout Itemize
 619 Syntax: number bit.extract(number base[, number bit0[, number bit1,...]])
 620 \end_layout
 621
 622 \begin_layout Standard
 623 Returns number that has bit0-th bit as bit 0, bit1-th bit as 1 and so on.
 624 \end_layout
 625
 626 \begin_layout Itemize
 627 Note: Bit numbers up to 51 should work reliably (then things start falling
 628  apart due to double precision issues).
 629 \end_layout
 630
 631 \begin_layout Itemize
 632 Note: There are two special bit positions, true and false, standing for
 633  always set bit and always clear bit.
 634 \end_layout
 635
 636 \begin_layout Subsection
 637 bit.value: Construct number with specified bits set
 638 \end_layout
 639
 640 \begin_layout Itemize
 641 Syntax: number bit.value([number bit1[, number bit2,...]])
 642 \end_layout
 643
 644 \begin_layout Standard
 645 Returns bitwise OR of 1 left shifted by <bit1> places, 1 left shifted by
 646  <bit2> places and so on.
 647  As special value, nil argument is no-op.
 648 \end_layout
 649
 650 \begin_layout Subsection
 651 bit.test_any: Test if any bit is set
 652 \end_layout
 653
 654 \begin_layout Itemize
 655 Syntax: boolean bit.test_any(number a, number b)
 656 \end_layout
 657
 658 \begin_layout Standard
 659 Returns true if bitwise and of <a> and <b> is nonzero, otherwise false.
 660 \end_layout
 661
 662 \begin_layout Subsection
 663 bit.test_all: Test if all bits are set
 664 \end_layout
 665
 666 \begin_layout Itemize
 667 Syntax: boolean bit.test_all(number a, number b)
 668 \end_layout
 669
 670 \begin_layout Standard
 671 Returns true if bitwise and of <a> and <b> equals <b>, otherwise false.
 672 \end_layout
 673
 674 \begin_layout Subsection
 675 bit.popcount: Population count
 676 \end_layout
 677
 678 \begin_layout Itemize
 679 Syntax: number bit.popcount(number a)
 680 \end_layout
 681
 682 \begin_layout Standard
 683 Returns number of set bits in <a>.
 684 \end_layout
 685
 686 \begin_layout Subsection
 687 bit.clshift: Chained left shift
 688 \end_layout
 689
 690 \begin_layout Itemize
 691 Syntax: (number, number) bit.clshift(number a, number b, [number amount,[number
 692  bits]])
 693 \end_layout
 694
 695 \begin_layout Standard
 696 Does chained left shift on <a>, <b> by <amount> positions (default 1), assuming
 697  numbers to be of specified number of bits <bits> (default 48).
 698 \end_layout
 699
 700 \begin_layout Subsection
 701 bit.crshift: Chained right shift
 702 \end_layout
 703
 704 \begin_layout Itemize
 705 Syntax: (number, number) bit.crshift(number a, number b, [number amount,[number
 706  bits]])
 707 \end_layout
 708
 709 \begin_layout Standard
 710 Does chained right shift on <a>, <b> by <amount> positions (default 1),
 711  assuming numbers to be of specified number of bits <bits> (default 48).
 712 \end_layout
 713
 714 \begin_layout Subsection
 715 bit.flagdecode: Decode bitfield into flags
 716 \end_layout
 717
 718 \begin_layout Itemize
 719 Syntax: string bit.flagdecode(number a, number bits, [string on, [string
 720  off]])
 721 \end_layout
 722
 723 \begin_layout Standard
 724 Return string of length bits where ith character is ith character of on
 725  if bit i is on, otherwise ith character of off.
 726  Out of range reads give last character.
 727 \end_layout
 728
 729 \begin_layout Itemize
 730 Note: <on> defaults to '*' if empty.
 731 \end_layout
 732
 733 \begin_layout Itemize
 734 Note: <off> defaults to '-' if empty.
 735 \end_layout
 736
 737 \begin_layout Subsection
 738 bit.rflagdecode: Decode bitfield into flags
 739 \end_layout
 740
 741 \begin_layout Itemize
 742 Syntax: string bit.rflagdecode(number a, number bits, [string on, [string
 743  off]])
 744 \end_layout
 745
 746 \begin_layout Standard
 747 Like bit.flagdecode, but outputs the string in the opposite order (most significa
 748 nt bit first).
 749 \end_layout
 750
 751 \begin_layout Standard
 752 \begin_inset Newpage pagebreak
 753 \end_inset
 754
 755
 756 \end_layout
 757
 758 \begin_layout Section
 759 Table gui:
 760 \end_layout
 761
 762 \begin_layout Itemize
 763 Functions that draw to screen can only only be called in on_paint and on_video
 764  callbacks or if non-default render queue has been set.
 765 \end_layout
 766
 767 \begin_layout Itemize
 768 Colors are 32-bit.
 769  Bits 0-7 are the blue component, bits 8-15 are the green component, bits
 770  16-23 are the red component, bits 24-31 are alpha component (0 is fully
 771  opaque, 255 is almost transparent).
 772  -1 is the fully transparent color.
 773 \end_layout
 774
 775 \begin_layout Itemize
 776 Alpha values greater than 127 do work properly.
 777 \end_layout
 778
 779 \begin_layout Itemize
 780 Origin of coordinates is at top left corner of game display area.
 781  Left and top gaps correspond to negative coordinates.
 782 \end_layout
 783
 784 \begin_layout Subsection
 785 gui.resolution: Get current resolution
 786 \end_layout
 787
 788 \begin_layout Itemize
 789 Syntax: (number, number) gui.resolution()
 790 \end_layout
 791
 792 \begin_layout Standard
 793 Returns 2-tuple (hresolution, vresolution).
 794 \end_layout
 795
 796 \begin_layout Subsection
 797 gui.left_gap/gui.right_gap/gui.top_gap/gui.bottom_gap: Set edge gaps
 798 \end_layout
 799
 800 \begin_layout Itemize
 801 Syntax: number gui.left_gap(number gap)
 802 \end_layout
 803
 804 \begin_layout Itemize
 805 Syntax: number gui.right_gap(number gap)
 806 \end_layout
 807
 808 \begin_layout Itemize
 809 Syntax: number gui.top_gap(number gap)
 810 \end_layout
 811
 812 \begin_layout Itemize
 813 Syntax: number gui.bottom_gap(number gap)
 814 \end_layout
 815
 816 \begin_layout Standard
 817 Set the specified edge gap to specified value <gap> (max gap is 8191).
 818  If successful, old gap is returned.
 819 \end_layout
 820
 821 \begin_layout Subsection
 822 gui.delta_left_gap/gui.delta_right_gap/gui.delta_top_gap/gui.delta_bottom_gap:
 823  Adjust edge gaps
 824 \end_layout
 825
 826 \begin_layout Itemize
 827 Syntax: number gui.delta_left_gap(number dgap)
 828 \end_layout
 829
 830 \begin_layout Itemize
 831 Syntax: number gui.delta_right_gap(number dgap)
 832 \end_layout
 833
 834 \begin_layout Itemize
 835 Syntax: number gui.delta_top_gap(number dgap)
 836 \end_layout
 837
 838 \begin_layout Itemize
 839 Syntax: number gui.delta_bottom_gap(number dgap)
 840 \end_layout
 841
 842 \begin_layout Standard
 843 Increase the specified edge gap by specified value <dgap> (max gap is 8191)
 844  and return the old gap (returns nothing on error).
 845 \end_layout
 846
 847 \begin_layout Subsection
 848 gui.text/gui.textH/gui.textV,gui.textHV: Draw text
 849 \end_layout
 850
 851 \begin_layout Itemize
 852 Syntax: none gui.text(number x, number y, string text[, number fgc[, number
 853  bgc]])
 854 \end_layout
 855
 856 \begin_layout Itemize
 857 Syntax: none gui.textH(number x, number y, string text[, number fgc[, number
 858  bgc]])
 859 \end_layout
 860
 861 \begin_layout Itemize
 862 Syntax: none gui.textV(number x, number y, string text[, number fgc[, number
 863  bgc]])
 864 \end_layout
 865
 866 \begin_layout Itemize
 867 Syntax: none gui.textHV(number x, number y, string text[, number fgc[, number
 868  bgc]])
 869 \end_layout
 870
 871 \begin_layout Standard
 872 Draw specified text on the GUI (each character cell is 8 or 16 wide and
 873  16 high).
 874  Parameters:
 875 \end_layout
 876
 877 \begin_layout Itemize
 878 x: X-coordinate to start the drawing from (and x-coordinate at begining
 879  of the lines).
 880 \end_layout
 881
 882 \begin_layout Itemize
 883 y: Y-coordinate to start the drawing from.
 884 \end_layout
 885
 886 \begin_layout Itemize
 887 text: The text to draw.
 888 \end_layout
 889
 890 \begin_layout Itemize
 891 fgc: Text color (default is 0xFFFFFF (white))
 892 \end_layout
 893
 894 \begin_layout Itemize
 895 bgc: Background color (default is -1 (transparent))
 896 \end_layout
 897
 898 \begin_layout Standard
 899 Note: The H variants draw at double width and V variants draw at double
 900  height.
 901 \end_layout
 902
 903 \begin_layout Subsection
 904 gui.rectangle: Draw a rectangle
 905 \end_layout
 906
 907 \begin_layout Itemize
 908 Syntax: none gui.rectangle(number x, number y, number width, number height[,
 909  number thickness[, number outline[, number fill]]])
 910 \end_layout
 911
 912 \begin_layout Standard
 913 Draw rectangle on the GUI.
 914  Parameters:
 915 \end_layout
 916
 917 \begin_layout Itemize
 918 x: X-coordinate of left edge.
 919 \end_layout
 920
 921 \begin_layout Itemize
 922 y: Y-coordinate of upper edge.
 923 \end_layout
 924
 925 \begin_layout Itemize
 926 width: Width of rectangle.
 927 \end_layout
 928
 929 \begin_layout Itemize
 930 height: Height of rectangle.
 931 \end_layout
 932
 933 \begin_layout Itemize
 934 thickness: Thickness of outline (default is 1).
 935 \end_layout
 936
 937 \begin_layout Itemize
 938 outline: Color of outline (default is 0xFFFFFF (white))
 939 \end_layout
 940
 941 \begin_layout Itemize
 942 fill: Color of fill (default is -1 (transparent))
 943 \end_layout
 944
 945 \begin_layout Subsection
 946 gui.box: Draw a 3D-effect box
 947 \end_layout
 948
 949 \begin_layout Itemize
 950 Syntax: none gui.box(number x, number y, number width, number height[, number
 951  thickness[, number outline1[,number outline2[, number fill]]]])
 952 \end_layout
 953
 954 \begin_layout Standard
 955 Draw rectangle with 3D effect on the GUI.
 956  Parameters:
 957 \end_layout
 958
 959 \begin_layout Itemize
 960 x: X-coordinate of left edge.
 961 \end_layout
 962
 963 \begin_layout Itemize
 964 y: Y-coordinate of upper edge.
 965 \end_layout
 966
 967 \begin_layout Itemize
 968 width: Width of rectangle.
 969 \end_layout
 970
 971 \begin_layout Itemize
 972 height: Height of rectangle.
 973 \end_layout
 974
 975 \begin_layout Itemize
 976 thickness: Thickness of outline (default is 1).
 977 \end_layout
 978
 979 \begin_layout Itemize
 980 outline1: First color of outline (default is 0xFFFFFF (white))
 981 \end_layout
 982
 983 \begin_layout Itemize
 984 outline2: First color of outline (default is 0x808080 (dark gray))
 985 \end_layout
 986
 987 \begin_layout Itemize
 988 fill: Color of fill (default is 0xC0C0C0 (light grayy))
 989 \end_layout
 990
 991 \begin_layout Subsection
 992 gui.pixel: Draw a single pixel
 993 \end_layout
 994
 995 \begin_layout Itemize
 996 Syntax: none gui.pixel(number x, number y[, number color])
 997 \end_layout
 998
 999 \begin_layout Standard
1000 Draw one pixel on the GUI.
1001  Parameters:
1002 \end_layout
1003
1004 \begin_layout Itemize
1005 x: X-coordinate of the pixel
1006 \end_layout
1007
1008 \begin_layout Itemize
1009 y: Y-coordinate of the pixel
1010 \end_layout
1011
1012 \begin_layout Itemize
1013 color: Color of the pixel (default is 0xFFFFFF (white))
1014 \end_layout
1015
1016 \begin_layout Subsection
1017 gui.crosshair: Draw a crosshair
1018 \end_layout
1019
1020 \begin_layout Itemize
1021 Syntax: none gui.crosshair(number x, number y[, number length[, number color]])
1022 \end_layout
1023
1024 \begin_layout Standard
1025 Draw a crosshair.
1026  Parameters:
1027 \end_layout
1028
1029 \begin_layout Itemize
1030 x: X-coordinate of the crosshair
1031 \end_layout
1032
1033 \begin_layout Itemize
1034 y: Y-coordinate of the crosshair
1035 \end_layout
1036
1037 \begin_layout Itemize
1038 length: Length of the crosshair lines (default 10).
1039 \end_layout
1040
1041 \begin_layout Itemize
1042 color: Color of the crosshair (default is 0xFFFFFF (white))
1043 \end_layout
1044
1045 \begin_layout Subsection
1046 gui.line: Draw a line
1047 \end_layout
1048
1049 \begin_layout Itemize
1050 Syntax: none gui.line(number x1, number y1, number x2, number y2[, number
1051  color])
1052 \end_layout
1053
1054 \begin_layout Standard
1055 Draw a thin line.
1056  Parameters:
1057 \end_layout
1058
1059 \begin_layout Itemize
1060 x1: X-coordinate of one end.
1061 \end_layout
1062
1063 \begin_layout Itemize
1064 y1: Y-coordinate of one end.
1065 \end_layout
1066
1067 \begin_layout Itemize
1068 x2: X-coordinate of the other end.
1069 \end_layout
1070
1071 \begin_layout Itemize
1072 y2: Y-coordinate of the other end.
1073 \end_layout
1074
1075 \begin_layout Itemize
1076 color: Color of the line (default is 0xFFFFFF (white)).
1077 \end_layout
1078
1079 \begin_layout Subsection
1080 gui.circle: Draw a (filled) circle
1081 \end_layout
1082
1083 \begin_layout Itemize
1084 Syntax: none gui.circle(number x, number y, number r[, number thick[, number
1085  border[, number fil]]])
1086 \end_layout
1087
1088 \begin_layout Standard
1089 Draw a circle.
1090  Parameters.
1091 \end_layout
1092
1093 \begin_layout Itemize
1094 x: X-coordinate of the center
1095 \end_layout
1096
1097 \begin_layout Itemize
1098 y: Y-coordinate of the center
1099 \end_layout
1100
1101 \begin_layout Itemize
1102 r: The radius of the circle
1103 \end_layout
1104
1105 \begin_layout Itemize
1106 thick: Border thickness
1107 \end_layout
1108
1109 \begin_layout Itemize
1110 border: Border color (default is 0xFFFFFF (white))
1111 \end_layout
1112
1113 \begin_layout Itemize
1114 fill: Fill color (default is -1 (transparent)).
1115 \end_layout
1116
1117 \begin_layout Subsection
1118 gui.bitmap_draw: Draw a bitmap
1119 \end_layout
1120
1121 \begin_layout Itemize
1122 Syntax: none gui.bitmap_draw(number x, number y, BITMAP bitmap, PALETTE palette)
1123 \end_layout
1124
1125 \begin_layout Itemize
1126 Syntax: none gui.bitmap_draw(number x, number y, DBITMAP bitmap)
1127 \end_layout
1128
1129 \begin_layout Standard
1130 Draw a bitmap <bitmap> on screen with specified palette <palette> (if bitmap
1131  is paletted) .
1132  Parameters:
1133 \end_layout
1134
1135 \begin_layout Itemize
1136 x: X-coordinate of left edge.
1137 \end_layout
1138
1139 \begin_layout Itemize
1140 y: Y-coordinate of top edge.
1141 \end_layout
1142
1143 \begin_layout Itemize
1144 bitmap: The bitmap to draw
1145 \end_layout
1146
1147 \begin_layout Itemize
1148 palette: The palette to draw the bitmap using.
1149 \end_layout
1150
1151 \begin_layout Subsection
1152 gui.palette_new: Create a new palette
1153 \end_layout
1154
1155 \begin_layout Itemize
1156 Syntax: PALETTE gui.palette_new()
1157 \end_layout
1158
1159 \begin_layout Standard
1160 Returns a new palette (initially all transparent).
1161
1162 \end_layout
1163
1164 \begin_layout Subsection
1165 gui.bitmap_new: Create a new bitmap
1166 \end_layout
1167
1168 \begin_layout Itemize
1169 Syntax: BITMAP/DBITMAP gui.bitmap_new(number w, number h, boolean direct[,
1170  bool icolor])
1171 \end_layout
1172
1173 \begin_layout Standard
1174 Returns a new bitmap/dbitmap.
1175 \end_layout
1176
1177 \begin_layout Standard
1178 Parameters:
1179 \end_layout
1180
1181 \begin_layout Itemize
1182 w: The width of new bitmap
1183 \end_layout
1184
1185 \begin_layout Itemize
1186 h: The height of new bitmap
1187 \end_layout
1188
1189 \begin_layout Itemize
1190 direct: If true, the returned bitmap is dbitmap, otherwise bitmap.
1191 \end_layout
1192
1193 \begin_layout Itemize
1194 icolor: Initital fill color (defaults to 0 on BITMAP, -1 on DBITMAP)
1195 \end_layout
1196
1197 \begin_layout Subsection
1198 gui.bitmap_load/gui.bitmap_load_str: Load a bitmap from file or string
1199 \end_layout
1200
1201 \begin_layout Itemize
1202 Syntax: DBITMAP/(BITMAP, PALETTE) gui.bitmap_load(string file[, string base])
1203 \end_layout
1204
1205 \begin_layout Itemize
1206 Syntax: DBITMAP/(BITMAP, PALETTE) gui.bitmap_load_str(string content)
1207 \end_layout
1208
1209 \begin_layout Standard
1210 Reads file <file> (resolved relative to <base>) or string <content> and
1211  returns loaded bitmap/dbitmap (if bitmap, the second return value is palette
1212  for bitmap).
1213 \end_layout
1214
1215 \begin_layout Subsection
1216 gui.bitmap_load_png/gui.bitmap_load_png_str: Load a bitmap from PNG
1217 \end_layout
1218
1219 \begin_layout Itemize
1220 Syntax: DBITMAP/(BITMAP, PALETTE) gui.bitmap_load_png(string file[, string
1221  base])
1222 \end_layout
1223
1224 \begin_layout Itemize
1225 Syntax: DBITMAP/(BITMAP, PALETTE) gui.bitmap_load_png_str(string content)
1226 \end_layout
1227
1228 \begin_layout Standard
1229 Load a bitmap from PNG file <file> (resolved relative to <base>) or BASE64
1230  encoded content <content>.
1231 \end_layout
1232
1233 \begin_layout Itemize
1234 If the PNG is of color type 3 (PALETTE), returns two value.
1235  First is BITMAP containing the image data from the PNG and second is PALETTE
1236  containg the palette data from the PNG.
1237 \end_layout
1238
1239 \begin_layout Itemize
1240 For color types 0 (GRAY), 2 (RGB), 4 (GRAY_ALPHA) and 6 (RGBA), returns
1241  one DBITMAP containg the image data loaded from the PNG.
1242 \end_layout
1243
1244 \begin_layout Subsection
1245 gui.bitmap_load_pal/gui.bitmap_load_pal_str: Load a palette
1246 \end_layout
1247
1248 \begin_layout Itemize
1249 Syntax: PALETTE gui.bitmap_load_pal(string file[, string base])
1250 \end_layout
1251
1252 \begin_layout Itemize
1253 Syntax: PALETTE gui.bitmap_load_pal_str(string content)
1254 \end_layout
1255
1256 \begin_layout Standard
1257 Load a palette from file <file>(resolved relative to <base>) or string <content>.
1258 \end_layout
1259
1260 \begin_layout Itemize
1261 The kinds of lines supported:
1262 \end_layout
1263
1264 \begin_deeper
1265 \begin_layout Itemize
1266 Blank or just whitespace: Ignored
1267 \end_layout
1268
1269 \begin_layout Itemize
1270 First non-whitespace is '#': Ignored
1271 \end_layout
1272
1273 \begin_layout Itemize
1274 <r> <g> <b>: Fully opaque color with specified RGB values (0-255)
1275 \end_layout
1276
1277 \begin_layout Itemize
1278 <r> <g> <b> <a>: Color with specified RGB values (0-255) and specified alpha
1279  (0-256, 0 being fully transparent and 256 fully opaque).
1280 \end_layout
1281
1282 \begin_layout Itemize
1283 transparent: Fully transparent color
1284 \end_layout
1285
1286 \end_deeper
1287 \begin_layout Subsection
1288 gui.palette_set: Set palette entry
1289 \end_layout
1290
1291 \begin_layout Itemize
1292 Syntax: none gui.palette_set(PALETTE palette, number index, number color)
1293 \end_layout
1294
1295 \begin_layout Standard
1296 Sets color in palette.
1297  Parameters:
1298 \end_layout
1299
1300 \begin_layout Itemize
1301 palette: The palette to manipulate
1302 \end_layout
1303
1304 \begin_layout Itemize
1305 index: Index of color (0-65535).
1306 \end_layout
1307
1308 \begin_layout Itemize
1309 color: The color value.
1310 \end_layout
1311
1312 \begin_layout Subsection
1313 gui.bitmap_pset: Set pixel in bitmap
1314 \end_layout
1315
1316 \begin_layout Itemize
1317 Syntax: none gui.bitmap_pset(BITMAP/DBITMAP bitmap, number x, number y, number
1318  color)
1319 \end_layout
1320
1321 \begin_layout Standard
1322 Sets specified pixel in bitmap.
1323  Parameters:
1324 \end_layout
1325
1326 \begin_layout Itemize
1327 bitmap: The bitmap to manipulate
1328 \end_layout
1329
1330 \begin_layout Itemize
1331 x: The x-coordinate of the pixel.
1332 \end_layout
1333
1334 \begin_layout Itemize
1335 y: The y-coordinate of the pixel.
1336 \end_layout
1337
1338 \begin_layout Itemize
1339 color: If bitmap is a bitmap, color index (0-65535).
1340  Otherwise color value.
1341 \end_layout
1342
1343 \begin_layout Subsection
1344 gui.bitmap_pget: Get pixel in bitmap
1345 \end_layout
1346
1347 \begin_layout Itemize
1348 Syntax: number gui.bitmap_pget(BITMAP/DBITMAP bitmap, number x, number y)
1349 \end_layout
1350
1351 \begin_layout Standard
1352 Gets specified pixel in bitmap.
1353  Parameters:
1354 \end_layout
1355
1356 \begin_layout Itemize
1357 bitmap: The bitmap to query
1358 \end_layout
1359
1360 \begin_layout Itemize
1361 x: The x-coordinate of the pixel.
1362 \end_layout
1363
1364 \begin_layout Itemize
1365 y: The y-coordinate of the pixel.
1366 \end_layout
1367
1368 \begin_layout Standard
1369 The bitmap color (color index if paletted, otherwise color value).
1370 \end_layout
1371
1372 \begin_layout Subsection
1373 gui.bitmap_size: Get size of bitmap
1374 \end_layout
1375
1376 \begin_layout Itemize
1377 Syntax: (number, number) gui.bitmap_size(BITMAP/DBITMAP bitmap)
1378 \end_layout
1379
1380 \begin_layout Standard
1381 Get size of bitmap <bitmap>.
1382  The first return is the width, the second is the height.
1383 \end_layout
1384
1385 \begin_layout Itemize
1386 Note: Can be used anywhere.
1387 \end_layout
1388
1389 \begin_layout Subsection
1390 gui.bitmap_blit: Blit a bitmap into another
1391 \end_layout
1392
1393 \begin_layout Itemize
1394 Syntax: none gui.bitmap_blit(BITMAP dest, number dx, number dy, BITMAP src,
1395  number sx, number sy, number w, number h[, number ck])
1396 \end_layout
1397
1398 \begin_layout Itemize
1399 Syntax: none gui.bitmap_blit(DBITMAP dest, number dx, number dy, DBITMAP
1400  src, number sx, number sy, number w, number h[, number ck])
1401 \end_layout
1402
1403 \begin_layout Itemize
1404 Syntax: none gui.bitmap_blit(DBITMAP dest, number dx, number dy, BITMAP src,
1405  PALETTE pal, number sx, number sy, number w, number h[, number ck])
1406 \end_layout
1407
1408 \begin_layout Standard
1409 Blit a part of bitmap to another.
1410  Parameters:
1411 \end_layout
1412
1413 \begin_layout Itemize
1414 dest: Destination to blit to.
1415 \end_layout
1416
1417 \begin_layout Itemize
1418 dx: left edge of target
1419 \end_layout
1420
1421 \begin_layout Itemize
1422 dy: Top edge of target
1423 \end_layout
1424
1425 \begin_layout Itemize
1426 src: The source to blit from.
1427 \end_layout
1428
1429 \begin_layout Itemize
1430 pal: The palette to use in blit.
1431 \end_layout
1432
1433 \begin_layout Itemize
1434 sx: left edge of source
1435 \end_layout
1436
1437 \begin_layout Itemize
1438 sy: Top edge of source
1439 \end_layout
1440
1441 \begin_layout Itemize
1442 w: Width of region
1443 \end_layout
1444
1445 \begin_layout Itemize
1446 h: Height of region.
1447 \end_layout
1448
1449 \begin_layout Itemize
1450 ck: Color key.
1451  Pixels of this color are not blitted.
1452 \end_layout
1453
1454 \begin_deeper
1455 \begin_layout Itemize
1456 If soruce bitmap is bitmap, this is color index of colorkey.
1457  Values outside range 0-65535 cause no key to be used as colorkey.
1458 \end_layout
1459
1460 \begin_layout Itemize
1461 If source bitmap is dbitmap, this is the color value of colorkey.
1462 \end_layout
1463
1464 \begin_layout Itemize
1465 May be absent or nil for no colorkey blit.
1466 \end_layout
1467
1468 \end_deeper
1469 \begin_layout Subsection
1470 gui.repaint: Arrange a repaint
1471 \end_layout
1472
1473 \begin_layout Itemize
1474 Syntax: none gui.repaint()
1475 \end_layout
1476
1477 \begin_layout Standard
1478 Request on_repaint() to happen as soon as possible.
1479 \end_layout
1480
1481 \begin_layout Subsection
1482 gui.synchronous_repaint: Paint screen now
1483 \end_layout
1484
1485 \begin_layout Itemize
1486 Syntax: none gui.synchronous_repaint(RENDERQUEUE queue)
1487 \end_layout
1488
1489 \begin_layout Standard
1490 Paints specified render queue on screen right there and then.
1491 \end_layout
1492
1493 \begin_layout Subsection
1494 gui.subframe_update: Enable/Disable subframe updates
1495 \end_layout
1496
1497 \begin_layout Itemize
1498 Syntax: none gui.subframe_update(boolean on)
1499 \end_layout
1500
1501 \begin_layout Standard
1502 Request subframe updates (calling on_paint() on subframes) to happen (<on>=true)
1503  or not happen (<on>=false).
1504 \end_layout
1505
1506 \begin_layout Subsection
1507 gui.screenshot: Write a screenshot
1508 \end_layout
1509
1510 \begin_layout Itemize
1511 Syntax: none gui.screenshot(string filename)
1512 \end_layout
1513
1514 \begin_layout Standard
1515 Write PNG screenshot of the current frame (no drawings) to specified file
1516  <filename>.
1517 \end_layout
1518
1519 \begin_layout Subsection
1520 gui.color: Compose a color.
1521 \end_layout
1522
1523 \begin_layout Itemize
1524 Syntax: number gui.color(number r, number g, number b[, number a])
1525 \end_layout
1526
1527 \begin_layout Standard
1528 Returns color (in notation Lua scripts use) corresponding to color (<r>,<g>,<b>)
1529 , each component in scale 0-255.
1530  If <a> is specified, that is alpha (0 is fully transparent, 256(sic) is
1531  fully opaque).
1532  The default alpha is 256.
1533 \end_layout
1534
1535 \begin_layout Subsection
1536 gui.status: Set status variable
1537 \end_layout
1538
1539 \begin_layout Itemize
1540 Syntax: none gui.status(string name, string value)
1541 \end_layout
1542
1543 \begin_layout Standard
1544 Set status field
1545 \begin_inset Quotes eld
1546 \end_inset
1547
1548 L[<name>]
1549 \begin_inset Quotes erd
1550 \end_inset
1551
1552  to <value> in status area.
1553 \end_layout
1554
1555 \begin_layout Subsection
1556 gui.rainbow: Rainbow color calculation
1557 \end_layout
1558
1559 \begin_layout Itemize
1560 Syntax: number gui.rainbow(number step, number steps[, number color])
1561 \end_layout
1562
1563 \begin_layout Standard
1564 Perform hue rotation of color <color> (default bright red), by <step> steps.
1565  The number of steps per full rotation is given by absolute value of <steps>.
1566 \end_layout
1567
1568 \begin_layout Standard
1569 If <steps> is negative, the rotation will be counterclockwise.
1570 \end_layout
1571
1572 \begin_layout Subsection
1573 gui.renderq_new: Create a render queue
1574 \end_layout
1575
1576 \begin_layout Itemize
1577 Syntax: RENDERQUEUE gui.renderq_new(number width, number height)
1578 \end_layout
1579
1580 \begin_layout Standard
1581 Create render queue with specified reported size and return it.
1582 \end_layout
1583
1584 \begin_layout Subsection
1585 gui.renderq_clear: Clear a render queue
1586 \end_layout
1587
1588 \begin_layout Itemize
1589 Syntax: none gui.renderq_clear(RENDERQUEUE queue)
1590 \end_layout
1591
1592 \begin_layout Standard
1593 Clear specified render queue.
1594 \end_layout
1595
1596 \begin_layout Subsection
1597 gui.renderq_set: Change active render queue
1598 \end_layout
1599
1600 \begin_layout Itemize
1601 Syntax: none gui.renderq_set(RENDERQUEUE queue)
1602 \end_layout
1603
1604 \begin_layout Standard
1605 Switch to specified render queue.
1606  Use nil as queue to switch to default queue.
1607 \end_layout
1608
1609 \begin_layout Itemize
1610 Note: When switched to another queue, all drawing functions work and draw
1611  there, even outside on_video/on_paint.
1612 \end_layout
1613
1614 \begin_layout Subsection
1615 gui.renderq_run: Run render queue
1616 \end_layout
1617
1618 \begin_layout Itemize
1619 Syntax: none gui.renderq_run(RENDERQUEUE queue)
1620 \end_layout
1621
1622 \begin_layout Standard
1623 Run specified render queue, copying the objects to current render queue.
1624
1625 \end_layout
1626
1627 \begin_layout Itemize
1628 Warning: Don't try to run the current render queue.
1629 \end_layout
1630
1631 \begin_layout Subsection
1632 gui.loadfont: Load a font file
1633 \end_layout
1634
1635 \begin_layout Itemize
1636 Syntax: CUSTOMFONT gui.loadfont(string filename)
1637 \end_layout
1638
1639 \begin_layout Standard
1640 Loads font from specified file (CUSTOMFONT object).
1641 \end_layout
1642
1643 \begin_layout Subsection
1644 CUSTOMFONT(): Render text to screen
1645 \end_layout
1646
1647 \begin_layout Itemize
1648 Syntax: none CUSTOMFONT(number x, number y, string text[, number fgc[, number
1649  bgc[, number hlc]]])
1650 \end_layout
1651
1652 \begin_layout Standard
1653 Draw string with custom font to screen.
1654  The parameters are the same as in gui.text, except <hlc> is the halo color
1655  (default is no halo).
1656
1657 \end_layout
1658
1659 \begin_layout Subsection
1660 gui.adjust_transparency: Adjust transparency of DBITMAP or PALETTE
1661 \end_layout
1662
1663 \begin_layout Itemize
1664 Syntax: none gui.adjust_transparency(DBITMAP obj, number adj)
1665 \end_layout
1666
1667 \begin_layout Itemize
1668 Syntax: none gui.adjust_transparency(PALETTE obj, number adj)
1669 \end_layout
1670
1671 \begin_layout Standard
1672 Multiply alpha channel of <obj> by <adj>/256.
1673  Useful for making
1674 \begin_inset Quotes eld
1675 \end_inset
1676
1677 ghosts
1678 \begin_inset Quotes erd
1679 \end_inset
1680
1681  out of solid bitmaps.
1682 \end_layout
1683
1684 \begin_layout Subsection
1685 gui.kill_frame: Kill video frame and associated sound
1686 \end_layout
1687
1688 \begin_layout Itemize
1689 Syntax: none gui.kill_frame()
1690 \end_layout
1691
1692 \begin_layout Standard
1693 Kills the currently dumped video frame + the associated sound.
1694  Only valid in on_video callback.
1695 \end_layout
1696
1697 \begin_layout Subsection
1698 gui.arrow: Draw an arrow
1699 \end_layout
1700
1701 \begin_layout Itemize
1702 Syntax: none gui.arrow(number x, number y, number length, number hwidth,
1703  number direction[, bool fill[, number color[, number twidth[, number hthick]]]]
1704 )
1705 \end_layout
1706
1707 \begin_layout Standard
1708 Draws an arrow using color <color>.
1709  The tip of arrow is at (<x>, <y>).
1710  Other parameters:
1711 \end_layout
1712
1713 \begin_layout Enumerate
1714 <length>: The length of arrow tail.
1715 \end_layout
1716
1717 \begin_layout Enumerate
1718 <hwidth>: The width of arrow head.
1719  Should be odd.
1720 \end_layout
1721
1722 \begin_layout Enumerate
1723 <direction>: Direction of arrow.
1724  0 is to right, +1 rotates 45 degrees counterclockwise.
1725 \end_layout
1726
1727 \begin_layout Enumerate
1728 <fill>: If true, fill the arrow head.
1729  Default false.
1730 \end_layout
1731
1732 \begin_layout Enumerate
1733 <twidth>: Tail width.
1734  Should be odd.
1735  Default 1.
1736 \end_layout
1737
1738 \begin_layout Enumerate
1739 <hthick>: Head thickness (only used if <fill> is false).
1740  Default is <twidth>.
1741 \end_layout
1742
1743 \begin_layout Subsection
1744 gui.tilemap: Create a tilemap
1745 \end_layout
1746
1747 \begin_layout Itemize
1748 Syntax: TILEMAP gui.tilemap(number w, number h, number bw, number bh)
1749 \end_layout
1750
1751 \begin_layout Standard
1752 Create a new tilemap of size <w>*<h>, with each cell being <bw>*<bh>.
1753 \end_layout
1754
1755 \begin_layout Subsection
1756 TILEMAP:getsize: Query tilemap size
1757 \end_layout
1758
1759 \begin_layout Itemize
1760 Syntax: number, number TILEMAP:getsize()
1761 \end_layout
1762
1763 \begin_layout Standard
1764 Return size of tilemap (width first).
1765 \end_layout
1766
1767 \begin_layout Subsection
1768 TILEMAP:getcsize: Query tilemap cell size
1769 \end_layout
1770
1771 \begin_layout Itemize
1772 Syntax: number, number TILEMAP:getcsize()
1773 \end_layout
1774
1775 \begin_layout Standard
1776 Return size of tilemap cell (width first).
1777 \end_layout
1778
1779 \begin_layout Subsection
1780 TILEMAP:get: Query tilemap cell
1781 \end_layout
1782
1783 \begin_layout Itemize
1784 Syntax: none TILEMAP:get(number x, number y)
1785 \end_layout
1786
1787 \begin_layout Itemize
1788 Syntax: dbitmap TILEMAP:get(number x, number y)
1789 \end_layout
1790
1791 \begin_layout Itemize
1792 Syntax: bitmap,palette TILEMAP:get(number x, number y)
1793 \end_layout
1794
1795 \begin_layout Standard
1796 Return contents of cell at <x>,<y>.
1797 \end_layout
1798
1799 \begin_layout Subsection
1800 TILEMAP:set: Set tilemap cell
1801 \end_layout
1802
1803 \begin_layout Itemize
1804 Syntax: none TILEMAP:set(number x, number y)
1805 \end_layout
1806
1807 \begin_layout Itemize
1808 Syntax: none TILEMAP:set(number x, number y, dbitmap b)
1809 \end_layout
1810
1811 \begin_layout Itemize
1812 Syntax: none TILEMAP:set(number x, number y, bitmap b, palette p)
1813 \end_layout
1814
1815 \begin_layout Standard
1816 Set contents of cell at <x>,<y>.
1817  If no bitmap/dbitmap is given, cell is cleared.
1818  Otherwise specified (d)bitmap is used (with specified palette if bitmap).
1819 \end_layout
1820
1821 \begin_layout Subsection
1822 TILEMAP:scroll: Scroll tilemap
1823 \end_layout
1824
1825 \begin_layout Itemize
1826 Syntax: none TILEMAP:scroll(number ox, number oy)
1827 \end_layout
1828
1829 \begin_layout Itemize
1830 Syntax: none TILEMAP:scroll(number ox, number oy, number x, number y, number
1831  w, number h)
1832 \end_layout
1833
1834 \begin_layout Itemize
1835 Syntax: none TILEMAP:scroll(number ox, number oy, number x, number y, number
1836  w, number h, boolean circx, boolean circy)
1837 \end_layout
1838
1839 \begin_layout Standard
1840 Scrolls the tilemap tiles by <ox>,<oy>.
1841  If <x>,<y>,<w>,<h> is specified, the scrolling is limited to <w>*<h> window
1842  starting at <x>,<y> (in tiles).
1843 \end_layout
1844
1845 \begin_layout Standard
1846 If <circx> is true, the window is circular in horizontal direction.
1847  Similarly with <circy> and vertical direciton.
1848 \end_layout
1849
1850 \begin_layout Subsection
1851 TILEMAP:draw: Draw tilemap
1852 \end_layout
1853
1854 \begin_layout Itemize
1855 Syntax: none TILEMAP:draw(number x, number y)
1856 \end_layout
1857
1858 \begin_layout Itemize
1859 Syntax: none TILEMAP:draw(number x, number y, number x0, number y0)
1860 \end_layout
1861
1862 \begin_layout Itemize
1863 Syntax: none TILEMAP:draw(number x, number y, number x0, number y0, number
1864  w, number h)
1865 \end_layout
1866
1867 \begin_layout Standard
1868 Draw tilemap at <x>,<y>.
1869  If <x0>,<y0> is given, that is tilemap coordinate (in pixels) of upper
1870  left edge.
1871  If <w>,<h> is given, that is the size of window to draw (in pixels)
1872 \end_layout
1873
1874 \begin_layout Standard
1875 \begin_inset Newpage pagebreak
1876 \end_inset
1877
1878
1879 \end_layout
1880
1881 \begin_layout Section
1882 table input
1883 \end_layout
1884
1885 \begin_layout Standard
1886 Input handling.
1887  Functions manipulating input are only available in on_input callback.
1888 \end_layout
1889
1890 \begin_layout Subsection
1891 input.get: Read controller button/axis (deprecated)
1892 \end_layout
1893
1894 \begin_layout Itemize
1895 Syntax: number input.get(number controller, number index)
1896 \end_layout
1897
1898 \begin_layout Standard
1899 Read the specified index <index> (zero-based) from specified controller
1900  <controller> (zero-based).
1901
1902 \end_layout
1903
1904 \begin_layout Subsection
1905 input.set: Write controller button/axis (deprecated)
1906 \end_layout
1907
1908 \begin_layout Itemize
1909 Syntax: none input.set(number controller, number index, number value)
1910 \end_layout
1911
1912 \begin_layout Standard
1913 Write the specified index <index> (zero-based) from specified controller
1914  <controller> (zero-based), storing value <value>.
1915 \end_layout
1916
1917 \begin_layout Subsection
1918 input.get2: Read controller button/axis
1919 \end_layout
1920
1921 \begin_layout Itemize
1922 Syntax: number input.get2(number port, number controller, number index)
1923 \end_layout
1924
1925 \begin_layout Standard
1926 Read the specified input tuple.
1927  Port 0 is system port.
1928 \end_layout
1929
1930 \begin_layout Subsection
1931 input.set2: Write controller button/axis
1932 \end_layout
1933
1934 \begin_layout Itemize
1935 Syntax: input.set2(number port, number controller, number index, number value)
1936 \end_layout
1937
1938 \begin_layout Standard
1939 Write the specified input tuple.
1940  Port 0 is system port.
1941 \end_layout
1942
1943 \begin_layout Subsection
1944 input.lcid_to_pcid2: Look up logical controller
1945 \end_layout
1946
1947 \begin_layout Itemize
1948 Syntax: (number, number) input.lcid_to_pcid2(number lcid)
1949 \end_layout
1950
1951 \begin_layout Standard
1952 Look up physical pcid pair (port, controller) corresponding to specified
1953  logical controller (1-based).
1954  Returns nothing if controller does not exist.
1955 \end_layout
1956
1957 \begin_layout Subsection
1958 input.port_type: Look up port type
1959 \end_layout
1960
1961 \begin_layout Itemize
1962 Syntax: string input.port_type(number port)
1963 \end_layout
1964
1965 \begin_layout Standard
1966 Return type of specified port.
1967 \end_layout
1968
1969 \begin_layout Subsection
1970 input.controller_info: Get information about controller
1971 \end_layout
1972
1973 \begin_layout Itemize
1974 Syntax: table input.controller_info(number port, number controller)
1975 \end_layout
1976
1977 \begin_layout Standard
1978 Get controller info for specified controller.
1979  If controller does not exist, returns nil.
1980  Otherwise returns a table with following fields:
1981 \end_layout
1982
1983 \begin_layout Itemize
1984 type (string): Type of the controller.
1985 \end_layout
1986
1987 \begin_layout Itemize
1988 class (string): Class of the controller.
1989 \end_layout
1990
1991 \begin_layout Itemize
1992 classnum (number): Number of the controller within its class (1-based)
1993 \end_layout
1994
1995 \begin_layout Itemize
1996 lcid (number): Logical controller number of the controller.
1997 \end_layout
1998
1999 \begin_layout Itemize
2000 button_count (number): Number of buttons on controller
2001 \end_layout
2002
2003 \begin_layout Itemize
2004 buttons (array): Array of following info about each button:
2005 \end_layout
2006
2007 \begin_deeper
2008 \begin_layout Itemize
2009 type (string): Type of button.
2010  Currently one of
2011 \begin_inset Quotes eld
2012 \end_inset
2013
2014 null
2015 \begin_inset Quotes erd
2016 \end_inset
2017
2018 ,
2019 \begin_inset Quotes eld
2020 \end_inset
2021
2022 button
2023 \begin_inset Quotes erd
2024 \end_inset
2025
2026 ,
2027 \begin_inset Quotes eld
2028 \end_inset
2029
2030 axis
2031 \begin_inset Quotes erd
2032 \end_inset
2033
2034 ,
2035 \begin_inset Quotes eld
2036 \end_inset
2037
2038 raxis
2039 \begin_inset Quotes erd
2040 \end_inset
2041
2042 .
2043 \end_layout
2044
2045 \begin_layout Itemize
2046 name (string): Name of button.
2047 \end_layout
2048
2049 \begin_layout Itemize
2050 symbol (string): Symbol of button.
2051  Only present for type
2052 \begin_inset Quotes eld
2053 \end_inset
2054
2055 button
2056 \begin_inset Quotes erd
2057 \end_inset
2058
2059 .
2060 \end_layout
2061
2062 \begin_layout Itemize
2063 hidden (boolean): True if hidden button.
2064
2065 \end_layout
2066
2067 \end_deeper
2068 \begin_layout Subsection
2069 input.veto_button: Veto a button press
2070 \end_layout
2071
2072 \begin_layout Itemize
2073 Syntax: none input.veto_button()
2074 \end_layout
2075
2076 \begin_layout Standard
2077 Signals that the button event should be vetoed.
2078  Only valid in on_button callback.
2079 \end_layout
2080
2081 \begin_layout Subsection
2082 input.geta: Get all buttons for controller (deprecated)
2083 \end_layout
2084
2085 \begin_layout Itemize
2086 Syntax: (number, number...) input.geta(number controller)
2087 \end_layout
2088
2089 \begin_layout Standard
2090 Get input state for entiere controller.
2091  Returns n return values.
2092 \end_layout
2093
2094 \begin_layout Itemize
2095 1st return value: Bitmask: bit i is set if i:th index is nonzero
2096 \end_layout
2097
2098 \begin_layout Itemize
2099 2nd- return value: value of i:th index.
2100 \end_layout
2101
2102 \begin_layout Subsection
2103 input.seta: Set all buttons for controller (deprecated)
2104 \end_layout
2105
2106 \begin_layout Itemize
2107 Syntax: none input.seta(number controller, number bitmask, number args...)
2108 \end_layout
2109
2110 \begin_layout Standard
2111 Set state for entiere controller.
2112  args is up to N values for indices (overriding values in bitmask if specified).
2113 \end_layout
2114
2115 \begin_layout Subsection
2116 input.controllertype: Get controller type (deprecated)
2117 \end_layout
2118
2119 \begin_layout Itemize
2120 syntax: string input.controllertype(number controller)
2121 \end_layout
2122
2123 \begin_layout Standard
2124 Get the type of controller as string.
2125 \end_layout
2126
2127 \begin_layout Subsection
2128 input.reset: Execute (delayed) reset
2129 \end_layout
2130
2131 \begin_layout Itemize
2132 Syntax: none input.reset([number cycles])
2133 \end_layout
2134
2135 \begin_layout Standard
2136 Execute reset.
2137  If <cycles> is greater than zero, do delayed reset.
2138  0 (or no value) causes immediate reset.
2139 \end_layout
2140
2141 \begin_layout Itemize
2142 Note: Only available with subframe flag false.
2143 \end_layout
2144
2145 \begin_layout Subsection
2146 input.raw: Return raw input data
2147 \end_layout
2148
2149 \begin_layout Itemize
2150 Syntax: table input.raw()
2151 \end_layout
2152
2153 \begin_layout Standard
2154 Returns table of tables of all available keys and axes.
2155  The first table is indexed by key name (platform-dependent!), and the inner
2156  table has the following fields:
2157 \end_layout
2158
2159 \begin_layout Itemize
2160 value: Last reported value for control
2161 \end_layout
2162
2163 \begin_deeper
2164 \begin_layout Itemize
2165 For keys: 1 for pressed, 0 for released.
2166 \end_layout
2167
2168 \begin_layout Itemize
2169 For axes: -32767...32767.
2170 \end_layout
2171
2172 \begin_layout Itemize
2173 For presure-sensitive buttons: 0...32767.
2174 \end_layout
2175
2176 \begin_layout Itemize
2177 For hats: Bitmask: 1=>Up, 2=>Right, 4=>Down, 8=>Left.
2178 \end_layout
2179
2180 \begin_layout Itemize
2181 For mouse: Coordinates relative to game area.
2182 \end_layout
2183
2184 \end_deeper
2185 \begin_layout Itemize
2186 ktype: Type of key (disabled, key, mouse, axis, hat, pressure).
2187 \end_layout
2188
2189 \begin_layout Subsection
2190 input.keyhook: Hook a key
2191 \end_layout
2192
2193 \begin_layout Itemize
2194 Syntax: none input.keyhook(string key, boolean state)
2195 \end_layout
2196
2197 \begin_layout Standard
2198 Requests that keyhook events to be sent for key <key> (<state>=true) or
2199  not sent (<state>=false).
2200 \end_layout
2201
2202 \begin_layout Subsection
2203 input.joyget: Get controls for controller
2204 \end_layout
2205
2206 \begin_layout Itemize
2207 Syntax: table input.joyget(number logical)
2208 \end_layout
2209
2210 \begin_layout Standard
2211 Returns table for current controls for specified logical controller <logical>.
2212  The names of fields vary by controller type.
2213 \end_layout
2214
2215 \begin_layout Itemize
2216 The buttons have the same name as those are referred to in other contexts
2217  in the emulator
2218 \end_layout
2219
2220 \begin_layout Itemize
2221 The analog axes are usually
2222 \begin_inset Quotes eld
2223 \end_inset
2224
2225 xaxis
2226 \begin_inset Quotes erd
2227 \end_inset
2228
2229  and
2230 \begin_inset Quotes eld
2231 \end_inset
2232
2233 yaxis
2234 \begin_inset Quotes erd
2235 \end_inset
2236
2237 .
2238 \end_layout
2239
2240 \begin_layout Itemize
2241 Each field is numeric or boolean depending on axis/button.
2242 \end_layout
2243
2244 \begin_layout Subsection
2245 input.joyset: Set controls for controller
2246 \end_layout
2247
2248 \begin_layout Itemize
2249 Syntax: none input.joyset(number controller, table controls)
2250 \end_layout
2251
2252 \begin_layout Standard
2253 Set the the state of specified controller to values specified in specified
2254  table.
2255 \end_layout
2256
2257 \begin_layout Itemize
2258 Each field can be boolean or number.
2259 \end_layout
2260
2261 \begin_layout Itemize
2262 Also, buttons allow strings, which cause value to be inverted.
2263 \end_layout
2264
2265 \begin_layout Subsection
2266 input.lcid_to_pcid: Look up logical controller (deprecated)
2267 \end_layout
2268
2269 \begin_layout Itemize
2270 Syntax: (number, number, number) input.lcid_to_pcid(number lcid)
2271 \end_layout
2272
2273 \begin_layout Standard
2274 Returns the legacy pcid for controller (or false if there isn't one), followed
2275  by pcid pair.
2276  Returns nothing if controller does not exist.
2277 \end_layout
2278
2279 \begin_layout Standard
2280 \begin_inset Newpage pagebreak
2281 \end_inset
2282
2283
2284 \end_layout
2285
2286 \begin_layout Section
2287 Table keyboard
2288 \end_layout
2289
2290 \begin_layout Standard
2291 Various keybinding-related functions
2292 \end_layout
2293
2294 \begin_layout Subsection
2295 keyboard.bind: Bind a key
2296 \end_layout
2297
2298 \begin_layout Itemize
2299 Syntax: none keyboard.bind(string mod, string mask, string key, string cmd)
2300 \end_layout
2301
2302 \begin_layout Standard
2303 Bind specified key with specified modifers to specified command.
2304 \end_layout
2305
2306 \begin_layout Subsection
2307 keyboard.unbind: Unbind a key
2308 \end_layout
2309
2310 \begin_layout Itemize
2311 Syntax: none keyboard.unbind(string mod, string mask, string key)
2312 \end_layout
2313
2314 \begin_layout Standard
2315 Unbind specified key with specified modifers.
2316 \end_layout
2317
2318 \begin_layout Subsection
2319 keyboard.alias: Set alias expansion
2320 \end_layout
2321
2322 \begin_layout Itemize
2323 Syntax: none keyboard.alias(string alias, string expansion)
2324 \end_layout
2325
2326 \begin_layout Standard
2327 Set expansion of given command.
2328 \end_layout
2329
2330 \begin_layout Standard
2331 \begin_inset Newpage pagebreak
2332 \end_inset
2333
2334
2335 \end_layout
2336
2337 \begin_layout Section
2338 Table subtitle
2339 \end_layout
2340
2341 \begin_layout Standard
2342 Subtitle handling
2343 \end_layout
2344
2345 \begin_layout Subsection
2346 subtitle.byindex: Look up start and length of subtitle by index
2347 \end_layout
2348
2349 \begin_layout Itemize
2350 Syntax: (number, number) subtitle.byindex(number i)
2351 \end_layout
2352
2353 \begin_layout Standard
2354 Read the frame and length of ith subtitle.
2355  Returns nothing if not present.
2356 \end_layout
2357
2358 \begin_layout Subsection
2359 subtitle.set: Write a subtitle
2360 \end_layout
2361
2362 \begin_layout Itemize
2363 Syntax: none subtitle.set(number f, number l, string txt)
2364 \end_layout
2365
2366 \begin_layout Standard
2367 Set the text of subtitle.
2368 \end_layout
2369
2370 \begin_layout Subsection
2371 subtitle.get: Read a subtitle
2372 \end_layout
2373
2374 \begin_layout Itemize
2375 Syntax: string subtitle.get(number f, number l)
2376 \end_layout
2377
2378 \begin_layout Standard
2379 Get the text of subtitle.
2380 \end_layout
2381
2382 \begin_layout Subsection
2383 subtitle.delete: Delete a subtitle
2384 \end_layout
2385
2386 \begin_layout Itemize
2387 Syntax: nonesubtitle.delete(number f, number l)
2388 \end_layout
2389
2390 \begin_layout Standard
2391 Delete specified subtitle.
2392 \end_layout
2393
2394 \begin_layout Standard
2395 \begin_inset Newpage pagebreak
2396 \end_inset
2397
2398
2399 \end_layout
2400
2401 \begin_layout Section
2402 Table hostmemory
2403 \end_layout
2404
2405 \begin_layout Standard
2406 Host memory handling (extra memory saved to savestates).
2407  Host memory starts empty.
2408 \end_layout
2409
2410 \begin_layout Itemize
2411 Reads out of range return false.
2412 \end_layout
2413
2414 \begin_layout Itemize
2415 Writes out of range extend the memory.
2416 \end_layout
2417
2418 \begin_layout Subsection
2419 hostmemory.read: Read byte from host memory
2420 \end_layout
2421
2422 \begin_layout Itemize
2423 Syntax: number hostmemory.read(number address)
2424 \end_layout
2425
2426 \begin_layout Standard
2427 Reads byte from hostmemory slot address <address>.
2428 \end_layout
2429
2430 \begin_layout Subsection
2431 hostmemory.write: Write byte to host memory
2432 \end_layout
2433
2434 \begin_layout Itemize
2435 Syntax: none hostmemory.write(number address, number value)
2436 \end_layout
2437
2438 \begin_layout Standard
2439 Writes hostmemory slot with value <value> 0-255.
2440 \end_layout
2441
2442 \begin_layout Subsection
2443 hostmemory.read{,s}{byte,{,h,d,q}word}: Read from host memory
2444 \end_layout
2445
2446 \begin_layout Itemize
2447 Syntax: number hostmemory.readbyte(number address)
2448 \end_layout
2449
2450 \begin_layout Itemize
2451 Syntax: number hostmemory.readsbyte(number address)
2452 \end_layout
2453
2454 \begin_layout Itemize
2455 Syntax: number hostmemory.readword(number address)
2456 \end_layout
2457
2458 \begin_layout Itemize
2459 Syntax: number hostmemory.readsword(number address)
2460 \end_layout
2461
2462 \begin_layout Itemize
2463 Syntax: number hostmemory.readhword(number address)
2464 \end_layout
2465
2466 \begin_layout Itemize
2467 Syntax: number hostmemory.readshword(number address)
2468 \end_layout
2469
2470 \begin_layout Itemize
2471 Syntax: number hostmemory.readdword(number address)
2472 \end_layout
2473
2474 \begin_layout Itemize
2475 Syntax: number hostmemory.readsdword(number address)
2476 \end_layout
2477
2478 \begin_layout Itemize
2479 Syntax: number hostmemory.readqword(number address)
2480 \end_layout
2481
2482 \begin_layout Itemize
2483 Syntax: number hostmemory.readsqword(number address)
2484 \end_layout
2485
2486 \begin_layout Standard
2487 Read elements (big-endian) from given address <address>.
2488 \end_layout
2489
2490 \begin_layout Itemize
2491 byte is 1 element
2492 \end_layout
2493
2494 \begin_layout Itemize
2495 word is 2 elements
2496 \end_layout
2497
2498 \begin_layout Itemize
2499 hword is 3 elements
2500 \end_layout
2501
2502 \begin_layout Itemize
2503 dword is 4 elements
2504 \end_layout
2505
2506 \begin_layout Itemize
2507 qword is 8 elements.
2508 \end_layout
2509
2510 \begin_layout Itemize
2511 The 's' variants do signed read.
2512 \end_layout
2513
2514 \begin_layout Subsection
2515 hostmemory.read{float,double}: Read from host memory
2516 \end_layout
2517
2518 \begin_layout Itemize
2519 syntax: number hostmemory.readfloat(number address)
2520 \end_layout
2521
2522 \begin_layout Itemize
2523 Syntax: number hostmemory.readdouble(number address)
2524 \end_layout
2525
2526 \begin_layout Standard
2527 Read elements (big-endian) floating-pont from given address <address>.
2528 \end_layout
2529
2530 \begin_layout Subsection
2531 hostmemory.write{,s}{byte,{,h,d,q}word}: Write to host memory
2532 \end_layout
2533
2534 \begin_layout Itemize
2535 Syntax: number hostmemory.writebyte(number address, number value)
2536 \end_layout
2537
2538 \begin_layout Itemize
2539 Syntax: number hostmemory.writesbyte(number address, number value)
2540 \end_layout
2541
2542 \begin_layout Itemize
2543 Syntax: number hostmemory.writeword(number address, number value)
2544 \end_layout
2545
2546 \begin_layout Itemize
2547 Syntax: number hostmemory.writesword(number address, number value)
2548 \end_layout
2549
2550 \begin_layout Itemize
2551 Syntax: number hostmemory.writehword(number address, number value)
2552 \end_layout
2553
2554 \begin_layout Itemize
2555 Syntax: number hostmemory.writeshword(number address, number value)
2556 \end_layout
2557
2558 \begin_layout Itemize
2559 Syntax: number hostmemory.writedword(number address, number value)
2560 \end_layout
2561
2562 \begin_layout Itemize
2563 Syntax: number hostmemory.writesdword(number address, number value)
2564 \end_layout
2565
2566 \begin_layout Itemize
2567 Syntax: number hostmemory.writeqword(number address, number value)
2568 \end_layout
2569
2570 \begin_layout Itemize
2571 Syntax: number hostmemory.writesqword(number address, number value)
2572 \end_layout
2573
2574 \begin_layout Standard
2575 Write value <value> to elements (little-endian) starting from given address
2576  <address>.
2577 \end_layout
2578
2579 \begin_layout Itemize
2580 byte is 1 element
2581 \end_layout
2582
2583 \begin_layout Itemize
2584 word is 2 elements
2585 \end_layout
2586
2587 \begin_layout Itemize
2588 hword is 3 elements
2589 \end_layout
2590
2591 \begin_layout Itemize
2592 dword is 4 elements
2593 \end_layout
2594
2595 \begin_layout Itemize
2596 qword is 8 elements.
2597 \end_layout
2598
2599 \begin_layout Itemize
2600 The 's' variants do signed write.
2601 \end_layout
2602
2603 \begin_layout Subsection
2604 hostmemory.write{float,double}: Write to host memory
2605 \end_layout
2606
2607 \begin_layout Itemize
2608 syntax: none hostmemory.readfloat(number address, number value)
2609 \end_layout
2610
2611 \begin_layout Itemize
2612 Syntax: none hostmemory.readdouble(number address, number value)
2613 \end_layout
2614
2615 \begin_layout Standard
2616 Write elements (big-endian) floating-pont to given address <address>, storing
2617  <value>.
2618 \end_layout
2619
2620 \begin_layout Standard
2621 \begin_inset Newpage pagebreak
2622 \end_inset
2623
2624
2625 \end_layout
2626
2627 \begin_layout Section
2628 Table movie
2629 \end_layout
2630
2631 \begin_layout Standard
2632 Movie handling
2633 \end_layout
2634
2635 \begin_layout Subsection
2636 movie.currentframe: Get current frame number
2637 \end_layout
2638
2639 \begin_layout Itemize
2640 Syntax: number movie.currentframe()
2641 \end_layout
2642
2643 \begin_layout Standard
2644 Return number of current frame.
2645 \end_layout
2646
2647 \begin_layout Subsection
2648 movie.framecount: Get move frame count
2649 \end_layout
2650
2651 \begin_layout Itemize
2652 Syntax: number movie.framecount()
2653 \end_layout
2654
2655 \begin_layout Standard
2656 Return number of frames in movie.
2657 \end_layout
2658
2659 \begin_layout Subsection
2660 movie.readonly: Is in readonly mode?
2661 \end_layout
2662
2663 \begin_layout Itemize
2664 Syntax: boolean movie.readonly()
2665 \end_layout
2666
2667 \begin_layout Standard
2668 Return true if in readonly mode, false if in readwrite.
2669 \end_layout
2670
2671 \begin_layout Subsection
2672 movie.rerecords: Movie rerecord count
2673 \end_layout
2674
2675 \begin_layout Itemize
2676 Syntax: number movie.rerecords()
2677 \end_layout
2678
2679 \begin_layout Standard
2680 Returns the current value of rerecord count.
2681 \end_layout
2682
2683 \begin_layout Subsection
2684 movie.set_readwrite: Set read-write mode.
2685 \end_layout
2686
2687 \begin_layout Itemize
2688 Syntax: none movie.set_readwrite()
2689 \end_layout
2690
2691 \begin_layout Standard
2692 Set readwrite mode (does not cause on_readwrite callback).
2693 \end_layout
2694
2695 \begin_layout Subsection
2696 movie.frame_subframes: Count subframes in frame
2697 \end_layout
2698
2699 \begin_layout Itemize
2700 Syntax: number movie.frame_subframes(number frame)
2701 \end_layout
2702
2703 \begin_layout Standard
2704 Count number of subframes in specified frame <frame> (frame numbers are
2705  1-based) and return that.
2706 \end_layout
2707
2708 \begin_layout Subsection
2709 movie.read_subframes: Read subframe data (deprecated)
2710 \end_layout
2711
2712 \begin_layout Itemize
2713 Syntax: table movie.read_subframes(number frame, number subframe)
2714 \end_layout
2715
2716 \begin_layout Standard
2717 Read specifed subframe in specified frame and return data as array.
2718 \end_layout
2719
2720 \begin_layout Subsection
2721 movie.read_rtc: Read current RTC time
2722 \end_layout
2723
2724 \begin_layout Itemize
2725 Syntax: (number, number) movie.read_rtc()
2726 \end_layout
2727
2728 \begin_layout Standard
2729 Returns the current value of the RTC as a pair (second, subsecond).
2730 \end_layout
2731
2732 \begin_layout Subsection
2733 movie.unsafe_rewind: Fast movie rewind to saved state
2734 \end_layout
2735
2736 \begin_layout Itemize
2737 Syntax: none movie.unsafe_rewind([UNSAFEREWIND state])
2738 \end_layout
2739
2740 \begin_layout Standard
2741 Start setting point for unsafe rewind or jump to point of unsafe rewind.
2742 \end_layout
2743
2744 \begin_layout Itemize
2745 If called without argument, causes emulator to start process of setting
2746  unsafe rewind point.
2747  When this has finished, callback on_set_rewind occurs, passing the rewind
2748  state to lua script.
2749 \end_layout
2750
2751 \begin_layout Itemize
2752 If called with argument, causes emulator rewind to passed rewind point as
2753  soon as possible.
2754  Readwrite mode is implicitly activated.
2755 \end_layout
2756
2757 \begin_layout Standard
2758 The following warnings apply to unsafe rewinding:
2759 \end_layout
2760
2761 \begin_layout Itemize
2762 There are no safety checks against misuse (that's what
2763 \begin_inset Quotes eld
2764 \end_inset
2765
2766 unsafe
2767 \begin_inset Quotes erd
2768 \end_inset
2769
2770  comes from)!
2771 \end_layout
2772
2773 \begin_layout Itemize
2774 Only call rewind from timeline rewind point was set from.
2775 \end_layout
2776
2777 \begin_layout Itemize
2778 Only call rewind from after the rewind point was set.
2779 \end_layout
2780
2781 \begin_layout Subsection
2782 movie.to_rewind: Load savestate as rewind point
2783 \end_layout
2784
2785 \begin_layout Itemize
2786 Syntax: UNSAFEREWIND movie.to_rewind(string filename)
2787 \end_layout
2788
2789 \begin_layout Standard
2790 Load specified savestate file <filename> as rewind point and return UNSAFEREWIND
2791  corresponding to it.
2792 \end_layout
2793
2794 \begin_layout Itemize
2795 Note: This operation does not take emulated time.
2796 \end_layout
2797
2798 \begin_layout Subsection
2799 movie.copy_movie/INPUTMOVIE::copy_movie: Copy movie to movie object
2800 \end_layout
2801
2802 \begin_layout Itemize
2803 Syntax: INPUTMOVIE movie.copy_movie([INPUTMOVIE movie])
2804 \end_layout
2805
2806 \begin_layout Itemize
2807 Syntax: INPUTMOVIE INPUTMOVIE::copy_movie()
2808 \end_layout
2809
2810 \begin_layout Standard
2811 Copies specified movie <movie>/current object (if none or nil, the active
2812  movie) as new movie object.
2813 \end_layout
2814
2815 \begin_layout Subsection
2816 movie.get_frame/INPUTMOVIE::get_frame: Read specified frame in movie.
2817 \end_layout
2818
2819 \begin_layout Itemize
2820 Syntax: INPUTFRAME movie.get_frame([INPUTMOVIE movie,] number frame)
2821 \end_layout
2822
2823 \begin_layout Itemize
2824 Syntax: INPUTFRAME INPUTMOVIE::get_frame(number frame);
2825 \end_layout
2826
2827 \begin_layout Standard
2828 Get INPUTFRAME object corresponding to specified frame in specified movie.
2829 \end_layout
2830
2831 \begin_layout Subsection
2832 movie.set_frame/INPUTMOVIE::set_frame: Write speicifed frame in movie.
2833 \end_layout
2834
2835 \begin_layout Itemize
2836 Syntax: none movie.set_frame([INPUTMOVIE movie,] number frame, INPUTFRAME
2837  data)
2838 \end_layout
2839
2840 \begin_layout Itemize
2841 Syntax: none INPUTMOVIE::set_frame(number frame, INPUTFRAME data)
2842 \end_layout
2843
2844 \begin_layout Standard
2845 Set data in specified frame.
2846 \end_layout
2847
2848 \begin_layout Itemize
2849 Note: Past can't be edited in active movie.
2850 \end_layout
2851
2852 \begin_layout Subsection
2853 movie.get_size/INPUTMOVIE::get_size: Get size of movie
2854 \end_layout
2855
2856 \begin_layout Itemize
2857 Syntax: integer movie.get_size([INPUTMOVIE movie])
2858 \end_layout
2859
2860 \begin_layout Itemize
2861 Syntax: integer INPUTMOVIE::get_size()
2862 \end_layout
2863
2864 \begin_layout Standard
2865 Return number of subframes in specified movie.
2866 \end_layout
2867
2868 \begin_layout Subsection
2869 movie.count_frames/INPUTMOVIE::count_frames: Count frames in movie
2870 \end_layout
2871
2872 \begin_layout Itemize
2873 Syntax: number movie.count_frames([INPUTMOVIE movie])
2874 \end_layout
2875
2876 \begin_layout Itemize
2877 Syntax: number INPUTMOVIE::count_frames()
2878 \end_layout
2879
2880 \begin_layout Standard
2881 Return number of frames in movie.
2882 \end_layout
2883
2884 \begin_layout Subsection
2885 movie.find_frame/INPUTMOVIE::find_frame: Find subframe corresponding to frame
2886 \end_layout
2887
2888 \begin_layout Itemize
2889 Syntax: number movie.find_frame([INPUTMOVIE movie], number frame)
2890 \end_layout
2891
2892 \begin_layout Itemize
2893 Syntax: number INPUTMOVIE::find_frame(number frame)
2894 \end_layout
2895
2896 \begin_layout Standard
2897 Returns starting subframe of given frame (frame numbers are 1-based).
2898  Returns -1 if frame number is bad.
2899 \end_layout
2900
2901 \begin_layout Subsection
2902 movie.blank_frame/INPUTMOVIE::blank_frame: Return a blank frame
2903 \end_layout
2904
2905 \begin_layout Itemize
2906 Syntax: INPUTFRAME movie.blank_frame([INPUTMOVIE movie])
2907 \end_layout
2908
2909 \begin_layout Itemize
2910 Syntax: INPUTFRAME INPUTMOVIE::blank_frame()
2911 \end_layout
2912
2913 \begin_layout Standard
2914 Return blank INPUTFRAME with frame type from specified movie.
2915 \end_layout
2916
2917 \begin_layout Subsection
2918 movie.append_frames/INPUTMOVIE::append_frames: Append blank frames
2919 \end_layout
2920
2921 \begin_layout Itemize
2922 Syntax: none movie.append_frames([INPUTMOVIE movie,] number frames)
2923 \end_layout
2924
2925 \begin_layout Itemize
2926 Syntax: none INPUTMOVIE::append_frames(number frames)
2927 \end_layout
2928
2929 \begin_layout Standard
2930 Append specified number <frames> of frames.
2931 \end_layout
2932
2933 \begin_layout Subsection
2934 movie.append_frame/INPUTMOVIE::append_frame: Append a frame
2935 \end_layout
2936
2937 \begin_layout Itemize
2938 Syntax: none movie.append_frame([INPUTMOVIE movie,] INPUTFRAME frame)
2939 \end_layout
2940
2941 \begin_layout Itemize
2942 Syntax: none INPUTMOVIE::append_frame(INPUTFRAME frame)
2943 \end_layout
2944
2945 \begin_layout Standard
2946 Append specified frame <frame>.
2947  Past of current movie can't be edited.
2948 \end_layout
2949
2950 \begin_layout Subsection
2951 movie.truncate/INPUTMOVIE::truncate: Truncate a movie.
2952 \end_layout
2953
2954 \begin_layout Itemize
2955 Syntax: none movie.truncate([INPUTMOVIE movie,] number frames)
2956 \end_layout
2957
2958 \begin_layout Itemize
2959 Syntax: none INPUTMOVIE::truncate(number frames)
2960 \end_layout
2961
2962 \begin_layout Standard
2963 Truncate the specified movie to specified number of frames.
2964 \end_layout
2965
2966 \begin_layout Subsection
2967 movie.edit/INPUTMOVIE::edit: Edit a movie
2968 \end_layout
2969
2970 \begin_layout Itemize
2971 Syntax: none movie.edit([INPUTMOVIE movie,] number frame, number port, number
2972  controller, number control, number/bool value)
2973 \end_layout
2974
2975 \begin_layout Itemize
2976 Syntax: none INPUTMOVIE::edit(number frame, number port, number controller,
2977  number control, number/bool value)
2978 \end_layout
2979
2980 \begin_layout Standard
2981 Change specified control in specified frame in specified movie.
2982  Past can't be edited in active movie.
2983 \end_layout
2984
2985 \begin_layout Subsection
2986 movie.copy_frames2: Copy frames between movies
2987 \end_layout
2988
2989 \begin_layout Itemize
2990 Syntax: none movie.copy_frames2([INPUTMOVIE dstmov,] number dst, [INPUTMOVIE
2991  srcmov,] number src, number count)
2992 \end_layout
2993
2994 \begin_layout Standard
2995 Copy specified number of frames between two movies.
2996  The copy proceeeds in forward direction.
2997 \end_layout
2998
2999 \begin_layout Subsection
3000 movie.copy_frames/INPUTMOVIE::copy_frames: Copy frames in movie
3001 \end_layout
3002
3003 \begin_layout Itemize
3004 Syntax: none movie.copy_frames([INPUTMOVIE mov,] number dst, number src,
3005  number count, bool backwards)
3006 \end_layout
3007
3008 \begin_layout Itemize
3009 Syntax: none INPUTMOVIE::copy_frames(number dst, number src, number count,
3010  bool backwards)
3011 \end_layout
3012
3013 \begin_layout Standard
3014 Copy specified number of frames from one point in movie to another.
3015  If backwards is true, the copy will be done backwards.
3016 \end_layout
3017
3018 \begin_layout Subsection
3019 movie.serialize/INPUTMOVIE::serialize: Serialize movie
3020 \end_layout
3021
3022 \begin_layout Itemize
3023 Syntax: none movie.serialize([INPUTMOVIE movie,] string filename, bool binary)
3024 \end_layout
3025
3026 \begin_layout Itemize
3027 Syntax: none INPUTMOIVE::serialize(string filename, bool binary)
3028 \end_layout
3029
3030 \begin_layout Standard
3031 Serialize given movie into file.
3032  If binary is true, binary format (more compact and much faster) is used.
3033 \end_layout
3034
3035 \begin_layout Subsection
3036 movie.unserialize: Unserialize movie
3037 \end_layout
3038
3039 \begin_layout Itemize
3040 Syntax: INPUTMOVIE movie.unserialize(INPUTFRAME template, string filename,
3041  bool binary)
3042 \end_layout
3043
3044 \begin_layout Standard
3045 Unserialize movie from file.
3046  The given frame is used as template to decide the frame type.
3047  If binary is true, binary format is decoded (much faster).
3048 \end_layout
3049
3050 \begin_layout Subsection
3051 movie.current_first_subframe: Return first subframe in current frame
3052 \end_layout
3053
3054 \begin_layout Itemize
3055 Syntax: number movie.current_first_subframe()
3056 \end_layout
3057
3058 \begin_layout Standard
3059 Returns first subframe in current frame.
3060 \end_layout
3061
3062 \begin_layout Subsection
3063 movie.pollcounter: Return poll counter for speified control
3064 \end_layout
3065
3066 \begin_layout Itemize
3067 Syntax: number movie.pollcounter(number port, number controller, number control)
3068 \end_layout
3069
3070 \begin_layout Standard
3071 Returns number of times the specified control has been polled this frame.
3072 \end_layout
3073
3074 \begin_layout Subsection
3075 INPUTFRAME::get_button: Get button
3076 \end_layout
3077
3078 \begin_layout Itemize
3079 Syntax: boolean INPUTFRAME::get_button(number port, number controller, number
3080  control)
3081 \end_layout
3082
3083 \begin_layout Standard
3084 Returns state of given button as boolean.
3085 \end_layout
3086
3087 \begin_layout Subsection
3088 INPUTFRAME::get_axis: Get axis
3089 \end_layout
3090
3091 \begin_layout Itemize
3092 Syntax: number INPUTFRAME::get_axis(number port, number controller, number
3093  control)
3094 \end_layout
3095
3096 \begin_layout Standard
3097 Returns state of given axis as number.
3098 \end_layout
3099
3100 \begin_layout Subsection
3101 INPUTFRAME::set_button/INPUTFRAME::set_axis: Set button or axis
3102 \end_layout
3103
3104 \begin_layout Itemize
3105 Syntax: none INPUTFRAME::set_button(number port, number controller, number
3106  control, number/bool value)
3107 \end_layout
3108
3109 \begin_layout Itemize
3110 Syntax: none INPUTFRAME::set_axis(number port, number controller, number
3111  control)
3112 \end_layout
3113
3114 \begin_layout Standard
3115 Set the given button/axis to given value.
3116 \end_layout
3117
3118 \begin_layout Subsection
3119 INPUTFRAME::serialize: Serialize a frame
3120 \end_layout
3121
3122 \begin_layout Itemize
3123 Syntax: string INPUTFRAME::serialize()
3124 \end_layout
3125
3126 \begin_layout Standard
3127 Return string representation of frame.
3128 \end_layout
3129
3130 \begin_layout Subsection
3131 INPUTFRAME::unserialize: Unserialize a frame
3132 \end_layout
3133
3134 \begin_layout Itemize
3135 Syntax: none INPUTFRAME::unserialize(string data)
3136 \end_layout
3137
3138 \begin_layout Standard
3139 Set current frame from given data.
3140 \end_layout
3141
3142 \begin_layout Subsection
3143 INPUTFRAME::get_stride: Get movie stride
3144 \end_layout
3145
3146 \begin_layout Itemize
3147 Syntax: number INPUTFRAME::get_stride()
3148 \end_layout
3149
3150 \begin_layout Standard
3151 Return number of bytes needed to store the input frame.
3152  Mainly useful for some debugging.
3153 \end_layout
3154
3155 \begin_layout Standard
3156 \begin_inset Newpage pagebreak
3157 \end_inset
3158
3159
3160 \end_layout
3161
3162 \begin_layout Section
3163 Table settings
3164 \end_layout
3165
3166 \begin_layout Standard
3167 Routines for settings manipulation
3168 \end_layout
3169
3170 \begin_layout Subsection
3171 settings.get: Get value of setting
3172 \end_layout
3173
3174 \begin_layout Itemize
3175 Syntax: string settings.get(string name)
3176 \end_layout
3177
3178 \begin_layout Standard
3179 Get value of setting <name>.
3180  If setting value can't be obtained, returns (nil, error message).
3181 \end_layout
3182
3183 \begin_layout Subsection
3184 settings.set: Set value of setting
3185 \end_layout
3186
3187 \begin_layout Itemize
3188 Syntax: none settings.set(string name, string value)
3189 \end_layout
3190
3191 \begin_layout Standard
3192 Set value <value> of setting <name>.
3193  If setting can't be set, returns (nil, error message).
3194 \end_layout
3195
3196 \begin_layout Standard
3197 \begin_inset Newpage pagebreak
3198 \end_inset
3199
3200
3201 \end_layout
3202
3203 \begin_layout Section
3204 Table memory
3205 \end_layout
3206
3207 \begin_layout Standard
3208 Contains various functions for managing memory
3209 \end_layout
3210
3211 \begin_layout Subsection
3212 memory.vma_count: Count number of VMAs.
3213 \end_layout
3214
3215 \begin_layout Itemize
3216 Syntax: number memory.vma_count()
3217 \end_layout
3218
3219 \begin_layout Standard
3220 Returns the number of VMAs
3221 \end_layout
3222
3223 \begin_layout Subsection
3224 memory.read_vma: Lookup VMA info by index
3225 \end_layout
3226
3227 \begin_layout Itemize
3228 Syntax: string memory.read_vma(number index)
3229 \end_layout
3230
3231 \begin_layout Standard
3232 Reads the specified VMA (indices start from zero).
3233  Trying to read invalid VMA gives nil.
3234  The read VMA is table with the following fields:
3235 \end_layout
3236
3237 \begin_layout Itemize
3238 region_name (string): The readable name of the VMA
3239 \end_layout
3240
3241 \begin_layout Itemize
3242 baseaddr (number): Base address of the VMA
3243 \end_layout
3244
3245 \begin_layout Itemize
3246 lastaddr (number): Last address in the VMA.
3247 \end_layout
3248
3249 \begin_layout Itemize
3250 size (number): The size of VMA in bytes.
3251 \end_layout
3252
3253 \begin_layout Itemize
3254 readonly (boolean): True of the VMA corresponds to ROM.
3255 \end_layout
3256
3257 \begin_layout Itemize
3258 iospace (boolean): True if the VMA is I/O space.
3259 \end_layout
3260
3261 \begin_layout Itemize
3262 native_endian (boolean): True if the VMA has native endian as opposed to
3263  little endian.
3264 \end_layout
3265
3266 \begin_layout Subsection
3267 memory.find_vma: Find VMA info by address
3268 \end_layout
3269
3270 \begin_layout Itemize
3271 Syntax: table memory.find_vma(number address)
3272 \end_layout
3273
3274 \begin_layout Standard
3275 Finds the VMA containing specified address.
3276  Returns table in the same format as read_vma or nil if not found.
3277 \end_layout
3278
3279 \begin_layout Subsection
3280 memory.read{,s}{byte,{,h,d,q}word}: Read memory
3281 \end_layout
3282
3283 \begin_layout Itemize
3284 Syntax: none memory.readbyte([string vma, ]number address)
3285 \end_layout
3286
3287 \begin_layout Itemize
3288 Syntax: none memory.readword([string vma, ]number address)
3289 \end_layout
3290
3291 \begin_layout Itemize
3292 Syntax: none memory.readhword([string vma, ]number address)
3293 \end_layout
3294
3295 \begin_layout Itemize
3296 Syntax: none memory.readdword([string vma, ]number address)
3297 \end_layout
3298
3299 \begin_layout Itemize
3300 Syntax: none memory.readqword([string vma, ]number address)
3301 \end_layout
3302
3303 \begin_layout Itemize
3304 Syntax: none memory.readsbyte([string vma, ]number address)
3305 \end_layout
3306
3307 \begin_layout Itemize
3308 Syntax: none memory.readsword([string vma, ]number address)
3309 \end_layout
3310
3311 \begin_layout Itemize
3312 Syntax: none memory.readshword([string vma, ]number address)
3313 \end_layout
3314
3315 \begin_layout Itemize
3316 Syntax: none memory.readsdword([string vma, ]number address)
3317 \end_layout
3318
3319 \begin_layout Itemize
3320 Syntax: none memory.readsqword([string vma, ]number address)
3321 \end_layout
3322
3323 \begin_layout Standard
3324 Reads the specified address <address> (if 's' variant is used, do undergo
3325  2's complement).
3326 \end_layout
3327
3328 \begin_layout Subsection
3329 memory.{,s}read_sg: Scatter/Gather read memory
3330 \end_layout
3331
3332 \begin_layout Itemize
3333 Syntax: none memory.read_sg(string/boolean/number...)
3334 \end_layout
3335
3336 \begin_layout Itemize
3337 Syntax: none memory.sread_sg(string/boolean/number...)
3338 \end_layout
3339
3340 \begin_layout Standard
3341 Perform (2s complement signed if using memory.sread_sg) scatter/gather read
3342  of memory.
3343  Each argument can be string, boolean or number:
3344 \end_layout
3345
3346 \begin_layout Itemize
3347 String: Set VMA addresses are relative to (e.g.
3348  'WRAM').
3349 \end_layout
3350
3351 \begin_layout Itemize
3352 boolean: If true, increment relative address by 1, if false, decrement by
3353  1.
3354  The new address is read as next higher byte.
3355 \end_layout
3356
3357 \begin_layout Itemize
3358 integer: Set the relative address to specified value and read the address
3359  as next higher byte.
3360 \end_layout
3361
3362 \begin_layout Subsection
3363 memory.write_sg: Scatter/Gather write memory
3364 \end_layout
3365
3366 \begin_layout Itemize
3367 Syntax: none memory.write_sg(number value, string/boolean/number...)
3368 \end_layout
3369
3370 \begin_layout Standard
3371 Perform scatter/gather write of value <value> on memory.
3372  Each argument can be string, boolean or number:
3373 \end_layout
3374
3375 \begin_layout Itemize
3376 String: Set VMA addresses are relative to (e.g.
3377  'WRAM').
3378 \end_layout
3379
3380 \begin_layout Itemize
3381 boolean: If true, increment relative address by 1, if false, decrement by
3382  1.
3383  The new address is read as next higher byte.
3384 \end_layout
3385
3386 \begin_layout Itemize
3387 integer: Set the relative address to specified value and read the address
3388  as next higher byte.
3389 \end_layout
3390
3391 \begin_layout Subsection
3392 memory.read{float,double}: Read memory
3393 \end_layout
3394
3395 \begin_layout Itemize
3396 Syntax: none memory.readfloat([string vma, ]number address)
3397 \end_layout
3398
3399 \begin_layout Itemize
3400 Syntax: none memory.readdouble([string vma, ]number address)
3401 \end_layout
3402
3403 \begin_layout Standard
3404 Reads the specified address <address>
3405 \end_layout
3406
3407 \begin_layout Subsection
3408 memory.write{byte,{,h,d,q}word,float,double}: Write memory
3409 \end_layout
3410
3411 \begin_layout Itemize
3412 Syntax: none memory.writebyte([string vma, ]number address, number value)
3413 \end_layout
3414
3415 \begin_layout Itemize
3416 Syntax: none memory.writeword([string vma, ]number address, number value)
3417 \end_layout
3418
3419 \begin_layout Itemize
3420 Syntax: none memory.writehword([string vma, ]number address, number value)
3421 \end_layout
3422
3423 \begin_layout Itemize
3424 Syntax: none memory.writedword([string vma, ]number address, number value)
3425 \end_layout
3426
3427 \begin_layout Itemize
3428 Syntax: none memory.writeqword([string vma, ]number address, number value)
3429 \end_layout
3430
3431 \begin_layout Itemize
3432 Syntax: none memory.writefloat([string vma, ]number address, number value)
3433 \end_layout
3434
3435 \begin_layout Itemize
3436 Syntax: none memory.writedouble([string vma, ]number address, number value)
3437 \end_layout
3438
3439 \begin_layout Standard
3440 Writes the specified value <value> (negative integer values undergo 2's
3441  complement) to specified address <address>.
3442 \end_layout
3443
3444 \begin_layout Subsection
3445 memory.map{{,s}{byte,{,h,d,q}word},float,double}: Map an array
3446 \end_layout
3447
3448 \begin_layout Itemize
3449 Syntax: userdata memory.map<type>([[string vma, ]number base, number size])
3450 \end_layout
3451
3452 \begin_layout Standard
3453 Returns a table mapping specified memory aperture for read/write.
3454  If parameters are omitted, entiere map space is the aperture.
3455 \end_layout
3456
3457 \begin_layout Itemize
3458 Type may be one of: byte, sbyte, word, sword, hword, shword, dword, sdword,
3459  qword, sqword, float or double.
3460 \end_layout
3461
3462 \begin_layout Subsection
3463 memory.hash_region: Hash region of memory
3464 \end_layout
3465
3466 \begin_layout Itemize
3467 Syntax: string memory.hash_region([string vma, ]number base, number size)
3468 \end_layout
3469
3470 \begin_layout Standard
3471 Hash specified number of bytes starting from specified address and return
3472  the SHA-256.
3473 \end_layout
3474
3475 \begin_layout Subsection
3476 memory.hash_state: Hash system state
3477 \end_layout
3478
3479 \begin_layout Itemize
3480 Syntax: string memory.hash_state()
3481 \end_layout
3482
3483 \begin_layout Standard
3484 Hash the current system state.
3485  Mainly useful for debugging savestates.
3486 \end_layout
3487
3488 \begin_layout Subsection
3489 memory.readregion: Read region of memory
3490 \end_layout
3491
3492 \begin_layout Itemize
3493 Syntax: table memory.readregion([string vma, ]number base, number size)
3494 \end_layout
3495
3496 \begin_layout Standard
3497 Read a region of memory.
3498 \end_layout
3499
3500 \begin_layout Itemize
3501 Warning: If the region crosses VMA boundary, the results are undefined.
3502 \end_layout
3503
3504 \begin_layout Subsection
3505 memory.writeregion: Write region of memory
3506 \end_layout
3507
3508 \begin_layout Itemize
3509 Syntax: none memory.writeregion([string vma, ]number base, number size, table
3510  data)
3511 \end_layout
3512
3513 \begin_layout Standard
3514 Write a region of memory.
3515 \end_layout
3516
3517 \begin_layout Itemize
3518 Warning: If the region crosses VMA boundary, the results are undefined.
3519 \end_layout
3520
3521 \begin_layout Subsection
3522 memory.map_structure: Create mmap structure
3523 \end_layout
3524
3525 \begin_layout Itemize
3526 syntax: MMAP_STRUCT memory.map_structure()
3527 \end_layout
3528
3529 \begin_layout Standard
3530 Returns a new mapping structure (MMAP_STRUCT)
3531 \end_layout
3532
3533 \begin_layout Subsection
3534 MMAP_STRUCT(): Bind key in mmap structure
3535 \end_layout
3536
3537 \begin_layout Itemize
3538 Syntax: none MMAP_STRUCT(string key, [string vma, ]number address, string
3539  type)
3540 \end_layout
3541
3542 \begin_layout Standard
3543 Bind key <key> in mmap structure to specified address <address> with specified
3544  type <type>.
3545 \end_layout
3546
3547 \begin_layout Itemize
3548 Type may be one of: byte, sbyte, word, sword, hword, shword, dword, sdword,
3549  qword, sqword, float or double.
3550 \end_layout
3551
3552 \begin_layout Subsection
3553 memory.read_expr: Evaluate memory watch expression
3554 \end_layout
3555
3556 \begin_layout Itemize
3557 Syntax: string memory.read_expr(string expr)
3558 \end_layout
3559
3560 \begin_layout Standard
3561 Evaluate specified watch expression and return result
3562 \end_layout
3563
3564 \begin_layout Subsection
3565 memory.action: Run core action
3566 \end_layout
3567
3568 \begin_layout Itemize
3569 memory.action(string action, [<params>])
3570 \end_layout
3571
3572 \begin_layout Standard
3573 Run core action.
3574  The different models expect parameters as:
3575 \end_layout
3576
3577 \begin_layout Itemize
3578 string: String
3579 \end_layout
3580
3581 \begin_layout Itemize
3582 numeric: numeric
3583 \end_layout
3584
3585 \begin_layout Itemize
3586 enumeration: String
3587 \end_layout
3588
3589 \begin_layout Itemize
3590 boolean: String
3591 \end_layout
3592
3593 \begin_layout Itemize
3594 toggle: None.
3595 \end_layout
3596
3597 \begin_layout Subsection
3598 memory.get_lag_flag: Get lag flag
3599 \end_layout
3600
3601 \begin_layout Itemize
3602 Syntax: boolean memory.get_lag_flag()
3603 \end_layout
3604
3605 \begin_layout Standard
3606 Get the value of core lag flag.
3607  True if this frame has been lag so far, false if poll has been detected.
3608 \end_layout
3609
3610 \begin_layout Subsection
3611 memory.set_lag_flag: Set lag flag
3612 \end_layout
3613
3614 \begin_layout Itemize
3615 Syntax: none memory.set_lag_flag(boolean flag)
3616 \end_layout
3617
3618 \begin_layout Standard
3619 Set the value of core lag flag.
3620  This flag automatically gets cleared if poll is detected, but can be forcibly
3621  set or cleared if game so requires.
3622 \end_layout
3623
3624 \begin_layout Itemize
3625 Should only be used in on_frame_emulated callback.
3626 \end_layout
3627
3628 \begin_layout Itemize
3629 Setting or clearing this affects the emulator lag counter.
3630 \end_layout
3631
3632 \begin_layout Standard
3633 \begin_inset Newpage pagebreak
3634 \end_inset
3635
3636
3637 \end_layout
3638
3639 \begin_layout Section
3640 Table memory2
3641 \end_layout
3642
3643 \begin_layout Standard
3644 Contains newer memory functions.
3645 \end_layout
3646
3647 \begin_layout Subsection
3648 memory2(): Get all VMA names.
3649 \end_layout
3650
3651 \begin_layout Itemize
3652 Syntax: table memory2()
3653 \end_layout
3654
3655 \begin_layout Standard
3656 Returns array of all valid VMA names.
3657 \end_layout
3658
3659 \begin_layout Subsection
3660 memory2.<vma>:info: Get VMA info
3661 \end_layout
3662
3663 \begin_layout Itemize
3664 Syntax: table memory2.<vma>:info()
3665 \end_layout
3666
3667 \begin_layout Standard
3668 Return table describing given VMA.
3669  Includes fields address, size, last, readonly, special and endian.
3670 \end_layout
3671
3672 \begin_layout Subsection
3673 memory2.<vma>:<op>: Read/Write memory
3674 \end_layout
3675
3676 \begin_layout Itemize
3677 Syntax: none memory2.<vma>:<op>(number offset, number value)
3678 \end_layout
3679
3680 \begin_layout Itemize
3681 Syntax: number memory2.<vma>:<op>(number offset)
3682 \end_layout
3683
3684 \begin_layout Standard
3685 Read/Write value from/to given VMA <vma> at given offset <offset> (must
3686  be in-range).
3687  The value written is <value>.
3688  <Op> is of form: [i][s]<type>, where:
3689 \end_layout
3690
3691 \begin_layout Itemize
3692 <type> is one of 'byte', 'word', 'hword', 'dword', 'qword', 'float', 'double'.
3693 \end_layout
3694
3695 \begin_layout Itemize
3696 'i' signifies that the value is treated as opposite-to-normal endianess,
3697 \end_layout
3698
3699 \begin_layout Itemize
3700 's' signifies that value is treated as signed (not available for floating-point).
3701 \end_layout
3702
3703 \begin_layout Subsection
3704 memory2.<vma>:read: Scatter-gather value read
3705 \end_layout
3706
3707 \begin_layout Itemize
3708 Syntax: number memory2.<vma>:read(number addr...)
3709 \end_layout
3710
3711 \begin_layout Standard
3712 Read value from given VMA <vma> at byte offsets <addr>..., given in order of
3713  increasing significance.
3714  Value of true and false are special.
3715  True increments address by 1, and false decrements address by 1.
3716 \end_layout
3717
3718 \begin_layout Subsection
3719 memory2.<vma>:sread: Signed scatter-gather value read
3720 \end_layout
3721
3722 \begin_layout Itemize
3723 Syntax: number memory2.<vma>:sread(number addr...)
3724 \end_layout
3725
3726 \begin_layout Standard
3727 Like memory2.<vma>:read, but reads signed values.
3728 \end_layout
3729
3730 \begin_layout Subsection
3731 memory2.<vma>:write: Scatter-gather value write
3732 \end_layout
3733
3734 \begin_layout Itemize
3735 Syntax: number memory2.<vma>:write(number val, number addr...)
3736 \end_layout
3737
3738 \begin_layout Standard
3739 Write value <val> to given VMA <vma> at byte offsets <addr>..., given in order
3740  of increasing significance.
3741  Value of true and false are special.
3742  True increments address by 1, and false decrements address by 1.
3743 \end_layout
3744
3745 \begin_layout Standard
3746 \begin_inset Newpage pagebreak
3747 \end_inset
3748
3749
3750 \end_layout
3751
3752 \begin_layout Section
3753 Table callback
3754 \end_layout
3755
3756 \begin_layout Standard
3757 Various callback-related functions.
3758 \end_layout
3759
3760 \begin_layout Subsection
3761 \begin_inset CommandInset label
3762 LatexCommand label
3763 name "sub:callback.register:-Register-a"
3764
3765 \end_inset
3766
3767 callback.register: Register a callback
3768 \end_layout
3769
3770 \begin_layout Itemize
3771 Syntax: function callback.register(string cbname, function cbfun);
3772 \end_layout
3773
3774 \begin_layout Standard
3775 Instruct function <cbfun> to be added to list of callbacks to call on event
3776  <cbname> (See section
3777 \begin_inset CommandInset ref
3778 LatexCommand ref
3779 reference "sec:Callbacks"
3780
3781 \end_inset
3782
3783 ).
3784  The callback name does not have the 'on_' prefix (e.g.
3785
3786 \begin_inset Quotes eld
3787 \end_inset
3788
3789 paint
3790 \begin_inset Quotes erd
3791 \end_inset
3792
3793 ).
3794  Returns <cbfun>.
3795 \end_layout
3796
3797 \begin_layout Subsection
3798 \begin_inset CommandInset label
3799 LatexCommand label
3800 name "sub:callback.unregister:-Unregister-"
3801
3802 \end_inset
3803
3804 callback.unregister: Unregister a callback
3805 \end_layout
3806
3807 \begin_layout Itemize
3808 Syntax: function callback.unregister(string cbname, function cbfun);
3809 \end_layout
3810
3811 \begin_layout Standard
3812 Instruct function <cbfun> to be removed from list of callbacks to call on
3813  event <cbname>.
3814 \end_layout
3815
3816 \begin_layout Subsection
3817 callback.<cbname>:register: Register callback
3818 \end_layout
3819
3820 \begin_layout Itemize
3821 Syntax: function callback.<cbname>:register(function cbfun)
3822 \end_layout
3823
3824 \begin_layout Standard
3825 Synonym for callback.register (section
3826 \begin_inset CommandInset ref
3827 LatexCommand ref
3828 reference "sub:callback.register:-Register-a"
3829
3830 \end_inset
3831
3832 ), albeit with callback name specified differently.
3833 \end_layout
3834
3835 \begin_layout Subsection
3836 callback.<cbname>:unregister: Register callback
3837 \end_layout
3838
3839 \begin_layout Itemize
3840 Syntax: function callback.<cbname>:unregister(function cbfun)
3841 \end_layout
3842
3843 \begin_layout Standard
3844 Synonym for callback.unregister (section
3845 \begin_inset CommandInset ref
3846 LatexCommand ref
3847 reference "sub:callback.unregister:-Unregister-"
3848
3849 \end_inset
3850
3851 ), albeit with callback name specified differently.
3852 \end_layout
3853
3854 \begin_layout Section
3855 Table _SYSTEM
3856 \end_layout
3857
3858 \begin_layout Standard
3859 Contains copy of global variables from time of Lua initialization.
3860  Non-writeable.
3861 \end_layout
3862
3863 \begin_layout Standard
3864 \begin_inset Newpage pagebreak
3865 \end_inset
3866
3867
3868 \end_layout
3869
3870 \begin_layout Section
3871 \begin_inset CommandInset label
3872 LatexCommand label
3873 name "sec:Callbacks"
3874
3875 \end_inset
3876
3877 Callbacks
3878 \end_layout
3879
3880 \begin_layout Standard
3881 Various callbacks to Lua that can occur.
3882 \end_layout
3883
3884 \begin_layout Subsection
3885 on_paint: Screen is being painted
3886 \end_layout
3887
3888 \begin_layout Itemize
3889 Callback: on_paint(bool not_synth)
3890 \end_layout
3891
3892 \begin_layout Standard
3893 Called when screen is being painted.
3894  Any gui.* calls requiring graphic context draw on the screen.
3895 \end_layout
3896
3897 \begin_layout Itemize
3898 not_synth is true if this hook is being called in response to received frame,
3899  false otherwise.
3900 \end_layout
3901
3902 \begin_layout Subsection
3903 on_video: Dumped video frame is being painted
3904 \end_layout
3905
3906 \begin_layout Itemize
3907 Callback: on_video()
3908 \end_layout
3909
3910 \begin_layout Standard
3911 Called when video dump frame is being painted.
3912  Any gui.* calls requiring graphic context draw on the video.
3913 \end_layout
3914
3915 \begin_layout Subsection
3916 on_frame_emulated: Frame emulation complete
3917 \end_layout
3918
3919 \begin_layout Itemize
3920 Callback: on_frame_emulated()
3921 \end_layout
3922
3923 \begin_layout Standard
3924 Called when emulating frame has completed and on_paint()/on_video() calls
3925  are about to be issued.
3926 \end_layout
3927
3928 \begin_layout Subsection
3929 on_frame: Frame emulation starting.
3930 \end_layout
3931
3932 \begin_layout Itemize
3933 Callback: on_frame()
3934 \end_layout
3935
3936 \begin_layout Standard
3937 Called on each starting whole frame.
3938 \end_layout
3939
3940 \begin_layout Subsection
3941 on_startup: Emulator startup complete
3942 \end_layout
3943
3944 \begin_layout Itemize
3945 Callback: on_startup()
3946 \end_layout
3947
3948 \begin_layout Standard
3949 Called when the emulator is starting (lsnes.rc and --run files has been run).
3950 \end_layout
3951
3952 \begin_layout Subsection
3953 on_rewind: Movie rewound to beginning
3954 \end_layout
3955
3956 \begin_layout Itemize
3957 Callback: on_rewind()
3958 \end_layout
3959
3960 \begin_layout Standard
3961 Called when rewind movie to beginning has completed.
3962 \end_layout
3963
3964 \begin_layout Subsection
3965 on_pre_load: Load operation is about to start
3966 \end_layout
3967
3968 \begin_layout Itemize
3969 Callback: on_pre_load(string name)
3970 \end_layout
3971
3972 \begin_layout Standard
3973 Called just before savestate/movie load occurs (note: loads are always delayed,
3974  so this occurs even when load was initiated by lua).
3975 \end_layout
3976
3977 \begin_layout Subsection
3978 on_err_Load: Load failed
3979 \end_layout
3980
3981 \begin_layout Itemize
3982 Callback: on_err_load(string name)
3983 \end_layout
3984
3985 \begin_layout Standard
3986 Called if loadstate goes wrong.
3987 \end_layout
3988
3989 \begin_layout Subsection
3990 on_post_load: Load completed
3991 \end_layout
3992
3993 \begin_layout Itemize
3994 Callback: on_post_load(string name, boolean was_savestate)
3995 \end_layout
3996
3997 \begin_layout Standard
3998 Called on successful loadstate.
3999  was_savestate gives if this was a savestate or a movie.
4000 \end_layout
4001
4002 \begin_layout Subsection
4003 on_pre_save: Save operation is about to start
4004 \end_layout
4005
4006 \begin_layout Itemize
4007 Callback: on_pre_save(string name, boolean is_savestate)
4008 \end_layout
4009
4010 \begin_layout Standard
4011 Called just before savestate save occurs (note: movie saves are synchronous
4012  and won't trigger these callbacks if called from Lua).
4013 \end_layout
4014
4015 \begin_layout Subsection
4016 on_err_save: Save failed
4017 \end_layout
4018
4019 \begin_layout Itemize
4020 Callback: on_err_save(string name)
4021 \end_layout
4022
4023 \begin_layout Standard
4024 Called if savestate goes wrong.
4025 \end_layout
4026
4027 \begin_layout Subsection
4028 on_post_save: Save completed
4029 \end_layout
4030
4031 \begin_layout Itemize
4032 Callback: on_post_save(string name, boolean is_savestate)
4033 \end_layout
4034
4035 \begin_layout Standard
4036 Called on successful savaestate.
4037  is_savestate gives if this was a savestate or a movie.
4038 \end_layout
4039
4040 \begin_layout Subsection
4041 on_quit: Emulator is shutting down
4042 \end_layout
4043
4044 \begin_layout Itemize
4045 Callback: on_quit()
4046 \end_layout
4047
4048 \begin_layout Standard
4049 Called when emulator is shutting down.
4050 \end_layout
4051
4052 \begin_layout Subsection
4053 on_input: Polling for input
4054 \end_layout
4055
4056 \begin_layout Standard
4057 Called when emulator is just sending input to bsnes core.
4058  Warning: This is called even in readonly mode, but the results are ignored.
4059 \end_layout
4060
4061 \begin_layout Subsection
4062 on_reset: System has been reset
4063 \end_layout
4064
4065 \begin_layout Itemize
4066 Callback: on_reset()
4067 \end_layout
4068
4069 \begin_layout Standard
4070 Called when system is reset.
4071 \end_layout
4072
4073 \begin_layout Subsection
4074 on_readwrite: Entered readwrite mode
4075 \end_layout
4076
4077 \begin_layout Itemize
4078 Callback: on_readwrite()
4079 \end_layout
4080
4081 \begin_layout Standard
4082 Called when moving into readwrite mode as result of
4083 \begin_inset Quotes eld
4084 \end_inset
4085
4086 set-rwmode
4087 \begin_inset Quotes erd
4088 \end_inset
4089
4090  command (note: moving to rwmode by Lua won't trigger this, as per recursive
4091  entry protection).
4092 \end_layout
4093
4094 \begin_layout Subsection
4095 on_snoop/on_snoop2: Snoop core controller reads
4096 \end_layout
4097
4098 \begin_layout Itemize
4099 Callback: on_snoop(number port, number controller, number index, number
4100  value)
4101 \end_layout
4102
4103 \begin_layout Itemize
4104 Callback: on_snoop2(number port, number controller, number index, number
4105  value)
4106 \end_layout
4107
4108 \begin_layout Standard
4109 Called each time bsnes asks for input.
4110  The value is the final value to be sent to bsnes core (readonly mode, autohold
4111  and autofire have been taken into account).
4112  Might be useful when translating movies to format suitable for console
4113  verification.
4114  Note: There is no way to modify the value to be sent.
4115 \end_layout
4116
4117 \begin_layout Itemize
4118 On_snoop2 is called instead of on_snoop if defined.
4119  Reserves port 0 for system, having first user port be port 1.
4120 \end_layout
4121
4122 \begin_layout Subsection
4123 on_keyhook: Hooked key/axis has been moved
4124 \end_layout
4125
4126 \begin_layout Itemize
4127 Callback: on_keyhook(string keyname, table state)
4128 \end_layout
4129
4130 \begin_layout Standard
4131 Sent when key that has keyhook events requested changes state.
4132  Keyname is name of the key (group) and state is the state (same kind as
4133  table values in input.raw).
4134 \end_layout
4135
4136 \begin_layout Subsection
4137 on_idle: Idle event
4138 \end_layout
4139
4140 \begin_layout Itemize
4141 Callback: on_idle()
4142 \end_layout
4143
4144 \begin_layout Standard
4145 Called when requested by set_idle_timeout(), the timeout has expired and
4146  emulator is waiting.
4147 \end_layout
4148
4149 \begin_layout Subsection
4150 on_timer: Timer event
4151 \end_layout
4152
4153 \begin_layout Itemize
4154 Callback: on_timer()
4155 \end_layout
4156
4157 \begin_layout Standard
4158 Called when requested by set_idle_timeout() and the timeout has expired
4159  (regardless if emulator is waiting).
4160 \end_layout
4161
4162 \begin_layout Subsection
4163 on_set_rewind: Rewind point has been set
4164 \end_layout
4165
4166 \begin_layout Itemize
4167 Callback: on_set_rewind(UNSAFEREWIND r)
4168 \end_layout
4169
4170 \begin_layout Standard
4171 Called when unsafe rewind object has been constructed.
4172 \end_layout
4173
4174 \begin_layout Subsection
4175 on_pre_rewind: Rewind is about to occur
4176 \end_layout
4177
4178 \begin_layout Itemize
4179 Callback: on_pre_rewind()
4180 \end_layout
4181
4182 \begin_layout Standard
4183 Called just before unsafe rewind is about to occur.
4184 \end_layout
4185
4186 \begin_layout Subsection
4187 on_post_rewind: Rewind has occured
4188 \end_layout
4189
4190 \begin_layout Itemize
4191 Callback: on_post_rewind()
4192 \end_layout
4193
4194 \begin_layout Standard
4195 Called just after unsafe rewind has occured.
4196 \end_layout
4197
4198 \begin_layout Subsection
4199 on_button: Button has been pressed
4200 \end_layout
4201
4202 \begin_layout Itemize
4203 Callback: on_button(number port, number controller, number index, string
4204  type)
4205 \end_layout
4206
4207 \begin_layout Standard
4208 Called on controller button press, with following parameters:
4209 \end_layout
4210
4211 \begin_layout Itemize
4212 port: Port number (0 is system)
4213 \end_layout
4214
4215 \begin_layout Itemize
4216 controller: Controller within port
4217 \end_layout
4218
4219 \begin_layout Itemize
4220 index: Index of button.
4221 \end_layout
4222
4223 \begin_layout Itemize
4224 type: Type of event, one of:
4225 \end_layout
4226
4227 \begin_deeper
4228 \begin_layout Itemize
4229 \begin_inset Quotes eld
4230 \end_inset
4231
4232 pressed
4233 \begin_inset Quotes erd
4234 \end_inset
4235
4236 : Button was pressed.
4237 \end_layout
4238
4239 \begin_layout Itemize
4240 \begin_inset Quotes eld
4241 \end_inset
4242
4243 released
4244 \begin_inset Quotes erd
4245 \end_inset
4246
4247 : Button was released.
4248 \end_layout
4249
4250 \begin_layout Itemize
4251 \begin_inset Quotes eld
4252 \end_inset
4253
4254 hold
4255 \begin_inset Quotes erd
4256 \end_inset
4257
4258 : Held.
4259 \end_layout
4260
4261 \begin_layout Itemize
4262 \begin_inset Quotes eld
4263 \end_inset
4264
4265 unhold
4266 \begin_inset Quotes erd
4267 \end_inset
4268
4269 : Released from hold.
4270 \end_layout
4271
4272 \begin_layout Itemize
4273 \begin_inset Quotes eld
4274 \end_inset
4275
4276 type
4277 \begin_inset Quotes erd
4278 \end_inset
4279
4280 : Typing input on button.
4281 \end_layout
4282
4283 \begin_layout Itemize
4284 \begin_inset Quotes eld
4285 \end_inset
4286
4287 untype
4288 \begin_inset Quotes erd
4289 \end_inset
4290
4291 : Typing input undone.
4292 \end_layout
4293
4294 \begin_layout Itemize
4295 \begin_inset Quotes eld
4296 \end_inset
4297
4298 autofire <duty> <cycle>
4299 \begin_inset Quotes erd
4300 \end_inset
4301
4302 : Autofire with specifie duty and cycle.
4303 \end_layout
4304
4305 \begin_layout Itemize
4306 \begin_inset Quotes eld
4307 \end_inset
4308
4309 autofire
4310 \begin_inset Quotes erd
4311 \end_inset
4312
4313 : Stop autofire.
4314 \end_layout
4315
4316 \begin_layout Itemize
4317 \begin_inset Quotes eld
4318 \end_inset
4319
4320 analog
4321 \begin_inset Quotes erd
4322 \end_inset
4323
4324 : Analog action on axis.
4325 \end_layout
4326
4327 \end_deeper
4328 \begin_layout Subsection
4329 on_movie_lost: Movie data is about to be lost
4330 \end_layout
4331
4332 \begin_layout Itemize
4333 Callback: on_movie_lost(STRING kind)
4334 \end_layout
4335
4336 \begin_layout Standard
4337 Called just before something would happen that could lose movie data.
4338  Kind can be:
4339 \end_layout
4340
4341 \begin_layout Itemize
4342 readwrite: Switching to readwrite mode.
4343 \end_layout
4344
4345 \begin_layout Itemize
4346 reload: ROM is being reloaded in readwrite mode.
4347 \end_layout
4348
4349 \begin_layout Itemize
4350 load: New movie is being loaded.
4351 \end_layout
4352
4353 \begin_layout Itemize
4354 unsaferewind: Unsafe rewind is happening.
4355 \end_layout
4356
4357 \end_body
4358 \end_document