Full Code of ahlstromcj/seq66 for AI

gitextract_2t7n7wkn/

├── .gitignore
├── ChangeLog
├── INSTALL
├── INSTALL.seq66.on.Ubuntu.md
├── Makefile.am
├── NEWS
├── README.md
├── RELNOTES
├── ROADMAP.md
├── Seq66cli/
│   ├── Makefile.am
│   ├── Seq66cli.pro
│   └── seq66rtcli.cpp
├── Seq66qt5/
│   ├── Makefile.am
│   ├── Seq66qt5.pro
│   └── seq66qt5.cpp
├── TODO
├── VERSION
├── autogen.sh
├── bootstrap
├── bootstrap.help
├── configure
├── configure.ac
├── configure.help
├── contrib/
│   ├── DIR_COLORS
│   ├── VMPK.conf
│   ├── Xdefaults.rc
│   ├── code/
│   │   ├── affinity.cpp
│   │   ├── ametro.c
│   │   ├── function_calls_gnu.c
│   │   ├── function_calls_gnu.h
│   │   ├── make_ametro
│   │   ├── qchannelpopup.cpp
│   │   ├── qchannelpopup.hpp
│   │   ├── readbinaryplist.c
│   │   ├── readbinaryplist.h
│   │   ├── ring_buffer.hpp
│   │   ├── test/
│   │   │   └── filename_split.cpp
│   │   └── ttymidi.c
│   ├── config.rpath
│   ├── control-map.rc
│   ├── dd-11/
│   │   ├── DD-11_Information.ods
│   │   └── dd-11-notes.log
│   ├── gdb/
│   │   ├── cgdbrc
│   │   └── dot-gdbinit
│   ├── git/
│   │   ├── git.odt
│   │   ├── git.text
│   │   ├── gitconfig
│   │   └── github_checklist.ods
│   ├── gvim.rc
│   ├── midi/
│   │   ├── 16-blank-patterns.midi
│   │   ├── 16-blank-patterns.text
│   │   ├── 1Bar-1920.midi
│   │   ├── 1Bar.midi
│   │   ├── 1Bar_2_tracks.midi
│   │   ├── 1Note.midi
│   │   ├── 24stones.mid
│   │   ├── 2B-test.midi
│   │   ├── 2Bars-song-export.midi
│   │   ├── 2Bars.midi
│   │   ├── 2rock.asc
│   │   ├── 2rock.hex
│   │   ├── 2rock.mid
│   │   ├── 2rock.midi
│   │   ├── 2stones.mid
│   │   ├── Carpet_of_the_Sun_karaoke_meta_text.mid
│   │   ├── Carpet_of_the_Sun_karaoke_meta_text.text
│   │   ├── CountryStrum.mid
│   │   ├── CountryStrum.midi
│   │   ├── Dixie04.mid
│   │   ├── Kraftwerk-Europe-Endless-exported.midi
│   │   ├── MIDI_sample-480.mid
│   │   ├── NR_Route_66.midi
│   │   ├── README
│   │   ├── XBars.midi
│   │   ├── ancestor.mid
│   │   ├── bad-linking.midi
│   │   ├── barrage.midi
│   │   ├── buffalo.midi
│   │   ├── chords000.midi
│   │   ├── click_4_4.midi
│   │   ├── click_7_8.midi
│   │   ├── colours-qt.midi
│   │   ├── controllers.midi
│   │   ├── dd-11-rock-sample-8.midi
│   │   ├── hanging-note-on.midi
│   │   ├── issue49.midi
│   │   ├── issue51-1920.midi
│   │   ├── issue51.midi
│   │   ├── multi-ports.midi
│   │   ├── mutes-long.midi
│   │   ├── mutes-test.midi
│   │   ├── one-shot-recording.midi
│   │   ├── patternfix.midi
│   │   ├── pitchwheel.midi
│   │   ├── play-pattern-1.text
│   │   ├── play.midi
│   │   ├── playtime.midi
│   │   ├── ppqn/
│   │   │   ├── ppqn-120.midi
│   │   │   ├── ppqn-192.midi
│   │   │   ├── ppqn-1920.midi
│   │   │   ├── ppqn-19200.midi
│   │   │   ├── ppqn-24.midi
│   │   │   ├── ppqn-240.midi
│   │   │   ├── ppqn-2400.midi
│   │   │   ├── ppqn-32.midi
│   │   │   ├── ppqn-384.midi
│   │   │   ├── ppqn-3840.midi
│   │   │   ├── ppqn-48.midi
│   │   │   ├── ppqn-480.midi
│   │   │   ├── ppqn-768.midi
│   │   │   ├── ppqn-7680.midi
│   │   │   ├── ppqn-96.midi
│   │   │   ├── ppqn-960.midi
│   │   │   └── ppqn-9600.midi
│   │   ├── program-test.midi
│   │   ├── random.midi
│   │   ├── reset.mid
│   │   ├── route66.midi
│   │   ├── scales-and-chords.midi
│   │   ├── seq66-scales.midi
│   │   ├── sets-test.midi
│   │   ├── simple-dd11-beat-test-GM.midi
│   │   ├── simple-dd11-beat-test.midi
│   │   ├── simpleblast-ch1-8th-notes-960.midi
│   │   ├── simpleblast-ch1-8th-notes.midi
│   │   ├── simpleblastbeat.midi
│   │   ├── songtest.midi
│   │   ├── songtest.text
│   │   ├── test.midi
│   │   ├── text.midi
│   │   ├── timesigs.midi
│   │   ├── trilogy.mid
│   │   ├── volume.midi
│   │   └── world7.midi
│   ├── midnam/
│   │   ├── README
│   │   └── Roland_MT-32.midnam
│   ├── mkinstalldirs-1.10
│   ├── non/
│   │   ├── NSM_API.txt
│   │   ├── messagelist.txt
│   │   ├── nsm-emails.txt
│   │   ├── nsm-proxy-h2.sh
│   │   ├── nsm.h
│   │   ├── nsm.sh
│   │   └── nsm_tendrils.txt
│   ├── notes/
│   │   ├── INSTALL4Ubuntu.md
│   │   ├── NEWS-template
│   │   ├── RELNOTES-0_99_0.md
│   │   ├── RPN.text
│   │   ├── bluez-alsa-notes.text
│   │   ├── bvi.text
│   │   ├── clang-macros-freebsd.text
│   │   ├── controls.ods
│   │   ├── drum_notes_gm_2.text
│   │   ├── event-from-bytes.text
│   │   ├── freebsd.text
│   │   ├── gcc-version.text
│   │   ├── gridlines.ods
│   │   ├── install-directories.text
│   │   ├── key-maps-dump.text
│   │   ├── key-names.text
│   │   ├── launchpad.text
│   │   ├── midi-control-in.text
│   │   ├── midi-messages.text
│   │   ├── midi-override-options.text
│   │   ├── msys2-packages.text
│   │   ├── pattern-fix-tests.text
│   │   ├── perf-callbacks.text
│   │   ├── performance.text
│   │   ├── pipewire.text
│   │   ├── ppqn-and-grids.ods
│   │   ├── program-banks.text
│   │   ├── q-hierarchy.text
│   │   ├── qw-az-keys.text
│   │   ├── rearrange-test.text
│   │   ├── scales-key-chord-handling.text
│   │   ├── session-mgrs.text
│   │   ├── snapshots.text
│   │   ├── styling.text
│   │   ├── win-virtual-keys.text
│   │   ├── windows-port-midi.text
│   │   └── zoom.text
│   ├── scripts/
│   │   ├── Jack
│   │   ├── README
│   │   ├── alsa.m4
│   │   ├── audio
│   │   ├── binfuncs
│   │   ├── bluejack
│   │   ├── build_debug_code.bat
│   │   ├── compositor
│   │   ├── configure-clang
│   │   ├── conk
│   │   ├── debug
│   │   ├── dot-xbindkeysrc
│   │   ├── gdarkseq66
│   │   ├── grayscale.sh
│   │   ├── gvo
│   │   ├── htmldoc
│   │   ├── make-checkout
│   │   ├── make-qt5-links
│   │   ├── mutetest
│   │   ├── naming
│   │   ├── notemapgen.py
│   │   ├── ordercp
│   │   ├── qbuild-bash
│   │   ├── qbuild.sh
│   │   ├── qbuildwin.sh
│   │   ├── qtctrun
│   │   ├── qtests
│   │   ├── reconf
│   │   ├── recordpa
│   │   ├── release
│   │   ├── seq66-nsm-proxy
│   │   ├── seq66.sed
│   │   ├── session
│   │   ├── strap_functions
│   │   ├── timid
│   │   ├── vd
│   │   ├── vo
│   │   ├── windows/
│   │   │   └── VMS_fixes.reg
│   │   └── ystart
│   ├── tests/
│   │   ├── 4x4/
│   │   │   ├── README
│   │   │   ├── buff.midi
│   │   │   ├── darkfix.qss
│   │   │   ├── qseq66-lp-mini-4x4.ctrl
│   │   │   ├── qseq66.ctrl
│   │   │   ├── qseq66.drums
│   │   │   ├── qseq66.mutes
│   │   │   ├── qseq66.playlist
│   │   │   ├── qseq66.rc
│   │   │   ├── qseq66.usr
│   │   │   └── synthstart
│   │   └── test_numbers.ods
│   ├── valgrind/
│   │   ├── fontconfig.supp
│   │   ├── glibc.supp
│   │   ├── helgrind-test.sh
│   │   ├── kde.supp
│   │   └── valgrind-leaks.sh
│   ├── vim-syntax/
│   │   ├── c.vim
│   │   ├── cpp.vim
│   │   ├── meson.vim
│   │   └── syncolor.vim
│   └── vim.rc
├── data/
│   ├── Makefile.am
│   ├── license.text
│   ├── linux/
│   │   ├── alsa_ports.rc
│   │   ├── ca_ports.rc
│   │   ├── jack/
│   │   │   ├── README
│   │   │   ├── jack_portmaps.rc
│   │   │   ├── jackctl
│   │   │   ├── pulseaudio/
│   │   │   │   ├── jack-post-start.sh
│   │   │   │   ├── jack-post-stop.sh
│   │   │   │   ├── jack-pre-start.sh
│   │   │   │   ├── jack-pre-stop.sh
│   │   │   │   └── repulse
│   │   │   ├── startjack
│   │   │   └── startqjack
│   │   ├── jack_ports.rc
│   │   ├── macros-APC40-mk2.ctrl
│   │   ├── macros-MMC.ctrl
│   │   ├── macros-launchpad-mini.ctrl
│   │   ├── macros-launchpad-pro-mk3.ctrl
│   │   ├── qseq66-alt-gray.palette
│   │   ├── qseq66-azerty-fr.keymap
│   │   ├── qseq66-azerty.ctrl
│   │   ├── qseq66-default.palette
│   │   ├── qseq66-gray.palette
│   │   ├── qseq66-lp-mini-8x8.ctrl
│   │   ├── qseq66-lp-mini-alt.ctrl
│   │   ├── qseq66-lp-mini-swapped.ctrl
│   │   ├── qseq66-lp-mini.ctrl
│   │   ├── qseq66-qwerty-us.keymap
│   │   ├── qseq66-swapped.ctrl
│   │   ├── qseq66.ctrl
│   │   ├── qseq66.drums
│   │   ├── qseq66.mutes
│   │   ├── qseq66.palette
│   │   ├── qseq66.playlist
│   │   ├── qseq66.rc
│   │   ├── qseq66.rc.legacy
│   │   ├── qseq66.usr
│   │   └── yoshimi-b4uacuse-gm.state
│   ├── midi/
│   │   ├── 16-blank-patterns.midi
│   │   ├── Carpet_of_the_Sun.text
│   │   ├── Chameleon-HHancock-Ov.midi
│   │   ├── EE-qsynth-presets.conf
│   │   ├── FM/
│   │   │   ├── README
│   │   │   ├── brecluse.mid
│   │   │   ├── carptsun.mid
│   │   │   ├── cbflitfm.mid
│   │   │   ├── dasmodel.mid
│   │   │   ├── grntamb.mid
│   │   │   ├── hapwandr.mid
│   │   │   ├── judyblue.mid
│   │   │   ├── k_seq11.mid
│   │   │   ├── longhair.mid
│   │   │   ├── marraksh.mid
│   │   │   ├── oxyg4bfm.mid
│   │   │   ├── pirates.mid
│   │   │   ├── pss680.mid
│   │   │   ├── qufrency.mid
│   │   │   ├── stdemo3.mid
│   │   │   ├── viceuk.mid
│   │   │   └── wallstsm.mid
│   │   ├── If_You_Could_Read_My_Mind.mid
│   │   ├── Kraftwerk-Europe_Endless-reconstructed.midi
│   │   ├── Kraftwerk-Europe_Endless.asc
│   │   ├── Kraftwerk-Europe_Endless.text
│   │   ├── PSS-790/
│   │   │   ├── ancestor.mid
│   │   │   ├── carptsun.mid
│   │   │   ├── cbflite.mid
│   │   │   └── old_love.mid
│   │   ├── Peter_Gunn-reconstructed.midi
│   │   ├── Peter_Gunn.text
│   │   ├── README
│   │   ├── b4uacufm.mid
│   │   ├── b4uacuse-gm-patchless.midi
│   │   ├── carptsun-4.midi
│   │   ├── carptsun.midi
│   │   ├── colours.midi
│   │   └── metro.midi
│   ├── readme.text
│   ├── readme.windows
│   ├── samples/
│   │   ├── GM.patches
│   │   ├── GM_DD-11.drums
│   │   ├── GM_PSS-790.drums
│   │   ├── GM_PSS-790_Multi.ini
│   │   ├── PSS-790.patches
│   │   ├── ca_midi.playlist
│   │   ├── dark-gradient.qss
│   │   ├── flat-rounded.qss
│   │   ├── green.palette
│   │   ├── green.qss
│   │   ├── grey-ghost.qss
│   │   ├── incrypt-66.palette
│   │   ├── incrypt-66.qss
│   │   ├── monogreen.palette
│   │   ├── monogreen.qss
│   │   ├── nanomap.ctrl
│   │   ├── perstfic-66.palette
│   │   ├── perstfic-66.qss
│   │   ├── qseq66-sample.palette
│   │   ├── qseq66.qss
│   │   ├── sample.playlist
│   │   ├── sample.usr
│   │   ├── sessions.rc
│   │   └── textfix.qss
│   ├── seq66cli/
│   │   ├── seq66cli.ctrl
│   │   ├── seq66cli.drums
│   │   ├── seq66cli.mutes
│   │   ├── seq66cli.playlist
│   │   ├── seq66cli.rc
│   │   └── seq66cli.usr
│   ├── share/
│   │   ├── applications/
│   │   │   └── seq66.desktop
│   │   ├── doc/
│   │   │   ├── Mini_Play_Info.ods
│   │   │   ├── akai-mini-play-mk3.ods
│   │   │   ├── control_keys.ods
│   │   │   ├── info/
│   │   │   │   ├── automation_keys.html
│   │   │   │   ├── common_keys.html
│   │   │   │   ├── mute_group_keys.html
│   │   │   │   ├── pattern_hotkeys.html
│   │   │   │   ├── seqroll_keys.html
│   │   │   │   └── songroll_keys.html
│   │   │   ├── launchpad-mini.ods
│   │   │   └── tutorial/
│   │   │       ├── configuration.html
│   │   │       ├── css/
│   │   │       │   ├── dark-slide.css
│   │   │       │   ├── emac-slide.css
│   │   │       │   ├── light-slide.css
│   │   │       │   └── slide.css
│   │   │       ├── faq.html
│   │   │       ├── home.html
│   │   │       ├── images/
│   │   │       │   └── README
│   │   │       ├── index.html
│   │   │       ├── introduction.html
│   │   │       ├── left-tree.html
│   │   │       ├── main_window.html
│   │   │       ├── main_window_patterns.html
│   │   │       ├── mutes_manager.html
│   │   │       ├── pagenotready.html
│   │   │       ├── pattern_editor.html
│   │   │       ├── pattern_tools.html
│   │   │       ├── playlist_manager.html
│   │   │       ├── sets_manager.html
│   │   │       ├── song_editor.html
│   │   │       ├── tutorial_first_startup.html
│   │   │       ├── tutorial_live_play.html
│   │   │       ├── tutorial_main.html
│   │   │       ├── tutorial_new_patterns.html
│   │   │       ├── tutorial_new_song.html
│   │   │       ├── tutorial_other_features.html
│   │   │       └── tutorial_song_performance.html
│   │   └── metainfo/
│   │       └── seq66.appdata.xml
│   ├── testing/
│   │   ├── mapping-snippet.rc
│   │   ├── simple-test.notemap
│   │   └── sixteen-ports-snippet.rc
│   ├── win/
│   │   ├── dark-theme.qss
│   │   ├── qpseq66.ctrl
│   │   ├── qpseq66.drums
│   │   ├── qpseq66.mutes
│   │   ├── qpseq66.palette
│   │   ├── qpseq66.playlist
│   │   ├── qpseq66.rc
│   │   ├── qpseq66.usr
│   │   └── win_midi.playlist
│   └── wrk/
│       ├── longhair.midi
│       ├── longhair.wrk
│       └── oxygen4b.wrk
├── desktop/
│   └── seq66.xpm
├── distros/
│   ├── README
│   ├── arch/
│   │   ├── README
│   │   └── package/
│   │       ├── PKGBUILD
│   │       └── PKGBUILD-alt
│   ├── fedora/
│   │   ├── README
│   │   └── seq66.spec
│   └── nixos/
│       ├── README
│       └── default.nix
├── doc/
│   ├── Makefile.am
│   ├── README
│   ├── dia/
│   │   ├── libseq66-headers.dia
│   │   ├── rtbusses.dia
│   │   └── rtjack_init.dia
│   ├── dox/
│   │   ├── Makefile.am
│   │   ├── doxy-common.cfg
│   │   ├── libseq66/
│   │   │   ├── libseq66.cfg
│   │   │   └── mainpage.dox
│   │   ├── libsessions/
│   │   │   ├── libsessions.cfg
│   │   │   └── mainpage.dox
│   │   ├── make-helper
│   │   ├── make_dox
│   │   ├── optimize
│   │   ├── seq_portmidi/
│   │   │   ├── mainpage.dox
│   │   │   └── seq_portmidi.cfg
│   │   └── seq_rtmidi/
│   │       ├── mainpage.dox
│   │       └── seq_rtmidi.cfg
│   └── latex/
│       ├── Makefile.am
│       ├── README
│       ├── images/
│       │   └── README
│       └── tex/
│           ├── Makefile.am
│           ├── alsa.tex
│           ├── concepts.tex
│           ├── configuration.tex
│           ├── defaultkeys.tex
│           ├── docs-structure.tex
│           ├── event_editor.tex
│           ├── first_start.tex
│           ├── headless.tex
│           ├── jack.tex
│           ├── kbd_mouse.tex
│           ├── kudos.tex
│           ├── launchpad_mini.tex
│           ├── live_grid.tex
│           ├── menu.tex
│           ├── meta_events.tex
│           ├── midi_export.tex
│           ├── midi_formats.tex
│           ├── mutes.tex
│           ├── palettes.tex
│           ├── pattern_editor.tex
│           ├── patterns_panel.tex
│           ├── playlist.tex
│           ├── port_mapping.tex
│           ├── preferences.tex
│           ├── recording.tex
│           ├── references.tex
│           ├── seq66-user-manual.tex
│           ├── sessions.tex
│           ├── setmaster.tex
│           ├── song_editor.tex
│           └── windows.tex
├── include/
│   ├── cli/
│   │   └── seq66-config.h
│   ├── config.h.in
│   └── qt/
│       ├── portmidi/
│       │   └── seq66-config.h
│       └── rtmidi/
│           └── seq66-config.h
├── libseq66/
│   ├── Makefile.am
│   ├── README
│   ├── include/
│   │   ├── Makefile.am
│   │   ├── base64_images.hpp
│   │   ├── cfg/
│   │   │   ├── basesettings.hpp
│   │   │   ├── cmdlineopts.hpp
│   │   │   ├── comments.hpp
│   │   │   ├── configfile.hpp
│   │   │   ├── midicontrolfile.hpp
│   │   │   ├── mutegroupsfile.hpp
│   │   │   ├── notemapfile.hpp
│   │   │   ├── patchesfile.hpp
│   │   │   ├── playlistfile.hpp
│   │   │   ├── rcfile.hpp
│   │   │   ├── rcsettings.hpp
│   │   │   ├── recent.hpp
│   │   │   ├── scales.hpp
│   │   │   ├── sessionfile.hpp
│   │   │   ├── settings.hpp
│   │   │   ├── userinstrument.hpp
│   │   │   ├── usermidibus.hpp
│   │   │   ├── usrfile.hpp
│   │   │   ├── usrsettings.hpp
│   │   │   └── zoomer.hpp
│   │   ├── ctrl/
│   │   │   ├── automation.hpp
│   │   │   ├── keycontainer.hpp
│   │   │   ├── keycontrol.hpp
│   │   │   ├── keymap.hpp
│   │   │   ├── keystroke.hpp
│   │   │   ├── midicontrol.hpp
│   │   │   ├── midicontrolbase.hpp
│   │   │   ├── midicontrolin.hpp
│   │   │   ├── midicontrolout.hpp
│   │   │   ├── midimacro.hpp
│   │   │   ├── midimacros.hpp
│   │   │   ├── midioperation.hpp
│   │   │   ├── opcontainer.hpp
│   │   │   └── opcontrol.hpp
│   │   ├── midi/
│   │   │   ├── businfo.hpp
│   │   │   ├── calculations.hpp
│   │   │   ├── controllers.hpp
│   │   │   ├── drums.hpp
│   │   │   ├── editable_event.hpp
│   │   │   ├── editable_events.hpp
│   │   │   ├── event.hpp
│   │   │   ├── eventlist.hpp
│   │   │   ├── jack_assistant.hpp
│   │   │   ├── mastermidibase.hpp
│   │   │   ├── mastermidibus.hpp
│   │   │   ├── midi_splitter.hpp
│   │   │   ├── midi_vector.hpp
│   │   │   ├── midi_vector_base.hpp
│   │   │   ├── midibase.hpp
│   │   │   ├── midibus.hpp
│   │   │   ├── midibus_common.hpp
│   │   │   ├── midibytes.hpp
│   │   │   ├── midifile.hpp
│   │   │   ├── patches.hpp
│   │   │   └── wrkfile.hpp
│   │   ├── os/
│   │   │   ├── daemonize.hpp
│   │   │   ├── shellexecute.hpp
│   │   │   └── timing.hpp
│   │   ├── play/
│   │   │   ├── clockslist.hpp
│   │   │   ├── inputslist.hpp
│   │   │   ├── metro.hpp
│   │   │   ├── mutegroup.hpp
│   │   │   ├── mutegroups.hpp
│   │   │   ├── notemapper.hpp
│   │   │   ├── performer.hpp
│   │   │   ├── playlist.hpp
│   │   │   ├── portslist.hpp
│   │   │   ├── screenset.hpp
│   │   │   ├── seq.hpp
│   │   │   ├── sequence.hpp
│   │   │   ├── setmapper.hpp
│   │   │   ├── setmaster.hpp
│   │   │   ├── songsummary.hpp
│   │   │   └── triggers.hpp
│   │   ├── seq66_features.h
│   │   ├── seq66_features.hpp
│   │   ├── seq66_platform_macros.h
│   │   ├── sessions/
│   │   │   ├── clinsmanager.hpp
│   │   │   └── smanager.hpp
│   │   └── util/
│   │       ├── automutex.hpp
│   │       ├── basic_macros.h
│   │       ├── basic_macros.hpp
│   │       ├── condition.hpp
│   │       ├── filefunctions.hpp
│   │       ├── named_bools.hpp
│   │       ├── palette.hpp
│   │       ├── recmutex.hpp
│   │       ├── rect.hpp
│   │       ├── ring_buffer.hpp
│   │       └── strfunctions.hpp
│   ├── libseq66.pro
│   └── src/
│       ├── Makefile.am
│       ├── cfg/
│       │   ├── basesettings.cpp
│       │   ├── cmdlineopts.cpp
│       │   ├── comments.cpp
│       │   ├── configfile.cpp
│       │   ├── midicontrolfile.cpp
│       │   ├── mutegroupsfile.cpp
│       │   ├── notemapfile.cpp
│       │   ├── patchesfile.cpp
│       │   ├── playlistfile.cpp
│       │   ├── rcfile.cpp
│       │   ├── rcsettings.cpp
│       │   ├── recent.cpp
│       │   ├── scales.cpp
│       │   ├── sessionfile.cpp
│       │   ├── settings.cpp
│       │   ├── userinstrument.cpp
│       │   ├── usermidibus.cpp
│       │   ├── usrfile.cpp
│       │   ├── usrsettings.cpp
│       │   └── zoomer.cpp
│       ├── ctrl/
│       │   ├── automation.cpp
│       │   ├── keycontainer.cpp
│       │   ├── keycontrol.cpp
│       │   ├── keymap.cpp
│       │   ├── keystroke.cpp
│       │   ├── midicontrol.cpp
│       │   ├── midicontrolbase.cpp
│       │   ├── midicontrolin.cpp
│       │   ├── midicontrolout.cpp
│       │   ├── midimacro.cpp
│       │   ├── midimacros.cpp
│       │   ├── midioperation.cpp
│       │   ├── opcontainer.cpp
│       │   ├── opcontrol.cpp
│       │   └── winkeys.hpp
│       ├── midi/
│       │   ├── businfo.cpp
│       │   ├── calculations.cpp
│       │   ├── controllers.cpp
│       │   ├── drums.cpp
│       │   ├── editable_event.cpp
│       │   ├── editable_events.cpp
│       │   ├── event.cpp
│       │   ├── eventlist.cpp
│       │   ├── jack_assistant.cpp
│       │   ├── mastermidibase.cpp
│       │   ├── midi_splitter.cpp
│       │   ├── midi_vector.cpp
│       │   ├── midi_vector_base.cpp
│       │   ├── midibase.cpp
│       │   ├── midibytes.cpp
│       │   ├── midifile.cpp
│       │   ├── patches.cpp
│       │   └── wrkfile.cpp
│       ├── os/
│       │   ├── daemonize.cpp
│       │   ├── shellexecute.cpp
│       │   └── timing.cpp
│       ├── play/
│       │   ├── clockslist.cpp
│       │   ├── inputslist.cpp
│       │   ├── metro.cpp
│       │   ├── mutegroup.cpp
│       │   ├── mutegroups.cpp
│       │   ├── notemapper.cpp
│       │   ├── performer.cpp
│       │   ├── playlist.cpp
│       │   ├── portslist.cpp
│       │   ├── screenset.cpp
│       │   ├── seq.cpp
│       │   ├── sequence.cpp
│       │   ├── setmapper.cpp
│       │   ├── setmaster.cpp
│       │   ├── songsummary.cpp
│       │   └── triggers.cpp
│       ├── seq66_features.cpp
│       ├── sessions/
│       │   ├── clinsmanager.cpp
│       │   └── smanager.cpp
│       └── util/
│           ├── automutex.cpp
│           ├── basic_macros.cpp
│           ├── condition.cpp
│           ├── filefunctions.cpp
│           ├── named_bools.cpp
│           ├── palette.cpp
│           ├── recmutex.cpp
│           ├── rect.cpp
│           ├── ring_buffer.cpp
│           └── strfunctions.cpp
├── libsessions/
│   ├── Makefile.am
│   ├── include/
│   │   ├── Makefile.am
│   │   └── nsm/
│   │       ├── nsmbase.hpp
│   │       ├── nsmclient.hpp
│   │       ├── nsmmessagesex.hpp
│   │       └── nsmserver.hpp
│   ├── libsessions.pro
│   └── src/
│       ├── Makefile.am
│       └── nsm/
│           ├── nsmbase.cpp
│           ├── nsmclient.cpp
│           ├── nsmmessagesex.cpp
│           └── nsmserver.cpp
├── licenses/
│   ├── LICENSE.FDL
│   ├── LICENSE.GPL
│   └── LICENSE.LGPL
├── m4/
│   ├── Makefile.am
│   ├── alsa.m4
│   ├── ax_cxx_compile_stdcxx.m4
│   ├── ax_cxx_compile_stdcxx_11.m4
│   ├── ax_have_qt.m4
│   ├── ax_have_qt_clang.m4
│   ├── ax_have_qt_ex.m4
│   ├── ax_have_qt_min.m4
│   ├── ax_prefix_config_h.m4
│   ├── ax_prog_flex.m4
│   ├── ax_pthread.m4
│   ├── ax_require_defined.m4
│   ├── gcc-version.m4
│   ├── inttypes.m4
│   ├── isc-posix.m4
│   ├── mm-common.m4
│   ├── mm-warnings.m4
│   ├── pkg.m4
│   ├── seq64_mingw_dll.m4
│   ├── threadlib.m4
│   ├── win32msc.m4
│   ├── xpc_debug.m4
│   ├── xpc_doxygen.m4
│   ├── xpc_errorlog.m4
│   ├── xpc_mingw.m4
│   ├── xpc_nullptr.m4
│   └── xpc_thisptr.m4
├── man/
│   ├── Makefile.am
│   ├── seq66.1
│   ├── seq66cli.1
│   └── sequencer66.1
├── nsis/
│   ├── README
│   ├── Seq66Constants.nsh
│   ├── Seq66Setup.nsi
│   ├── build_release_package.bat
│   └── x64.nsh
├── pack
├── packages
├── resources/
│   ├── icons/
│   │   └── route66.xpm
│   ├── pixmaps/
│   │   ├── Makefile.am
│   │   ├── bus.xpm
│   │   ├── chord.xpm
│   │   ├── chord3-inv.xpm
│   │   ├── chord3.xpm
│   │   ├── collapse.xpm
│   │   ├── copy.xpm
│   │   ├── del.xpm
│   │   ├── down.xpm
│   │   ├── drum.xpm
│   │   ├── exp_rec_on.xpm
│   │   ├── expand.xpm
│   │   ├── expandgrid.xpm
│   │   ├── filter_off.xpm
│   │   ├── filter_on.xpm
│   │   ├── finger.xpm
│   │   ├── follow.xpm
│   │   ├── fruity.xpm
│   │   ├── hex_off.xpm
│   │   ├── hex_on.xpm
│   │   ├── hide.xpm
│   │   ├── ins.xpm
│   │   ├── jack.xpm
│   │   ├── jack_black.xpm
│   │   ├── key.xpm
│   │   ├── learn.xpm
│   │   ├── learn2.xpm
│   │   ├── length.xpm
│   │   ├── length_red.xpm
│   │   ├── length_short.xpm
│   │   ├── length_short_inv.xpm
│   │   ├── live_mode.xpm
│   │   ├── logo.xpm
│   │   ├── loop.xpm
│   │   ├── menu.xpm
│   │   ├── menu_empty.xpm
│   │   ├── menu_empty_inv.xpm
│   │   ├── menu_full.xpm
│   │   ├── menu_full_inv.xpm
│   │   ├── metro.xpm
│   │   ├── metro_on.xpm
│   │   ├── midi.xpm
│   │   ├── muting.xpm
│   │   ├── n_rec_on.xpm
│   │   ├── note_length.xpm
│   │   ├── note_length_inv.xpm
│   │   ├── numbers_off.xpm
│   │   ├── numbers_on.xpm
│   │   ├── panic.xpm
│   │   ├── panic2.xpm
│   │   ├── pause.xpm
│   │   ├── perfedit.xpm
│   │   ├── play.xpm
│   │   ├── play2.xpm
│   │   ├── play_on.xpm
│   │   ├── q_rec.xpm
│   │   ├── q_rec_on.xpm
│   │   ├── quantize.xpm
│   │   ├── quantize_inv.xpm
│   │   ├── rec.xpm
│   │   ├── rec_ex_buss.xpm
│   │   ├── rec_ex_channel.xpm
│   │   ├── rec_ex_normal.xpm
│   │   ├── rec_on.xpm
│   │   ├── redo.xpm
│   │   ├── right.xpm
│   │   ├── route66.xpm
│   │   ├── route66rwb-32x32.xpm
│   │   ├── route66rwb-64x64.xpm
│   │   ├── scale.xpm
│   │   ├── seq-editor.xpm
│   │   ├── seq.xpm
│   │   ├── seq66.xpm
│   │   ├── seq66_32.xpm
│   │   ├── sequences.xpm
│   │   ├── show.xpm
│   │   ├── show_bars_off.xpm
│   │   ├── show_bars_on.xpm
│   │   ├── snap.xpm
│   │   ├── song-editor.xpm
│   │   ├── song-snap.xpm
│   │   ├── song_mode.xpm
│   │   ├── song_rec.xpm
│   │   ├── song_rec_no_snap.xpm
│   │   ├── song_rec_off.xpm
│   │   ├── song_rec_on.xpm
│   │   ├── song_record.xpm
│   │   ├── stop.xpm
│   │   ├── t_rec_on.xpm
│   │   ├── thru.xpm
│   │   ├── thru_on.xpm
│   │   ├── tools.xpm
│   │   ├── transport_follow.xpm
│   │   ├── transpose.xpm
│   │   ├── tux.xpm
│   │   ├── undo.xpm
│   │   ├── up.xpm
│   │   ├── up_inv.xpm
│   │   ├── zoom.xpm
│   │   ├── zoom_in.xpm
│   │   └── zoom_out.xpm
│   └── seq66_win.rc
├── seq66.pro
├── seq_portmidi/
│   ├── Makefile.am
│   ├── README
│   ├── include/
│   │   ├── Makefile.am
│   │   ├── mastermidibus_pm.hpp
│   │   ├── midibus_pm.hpp
│   │   ├── pmerrmm.h
│   │   ├── pminternal.h
│   │   ├── pmlinux.h
│   │   ├── pmlinuxalsa.h
│   │   ├── pmmac.h
│   │   ├── pmutil.h
│   │   ├── pmwinmm.h
│   │   ├── portmidi.h
│   │   └── porttime.h
│   ├── seq_portmidi.pro
│   └── src/
│       ├── Makefile.am
│       ├── mastermidibus.cpp
│       ├── midibus.cpp
│       ├── pmerrmm.c
│       ├── pmlinux.c
│       ├── pmlinuxalsa.c
│       ├── pmmac.c
│       ├── pmmacosxcm.c
│       ├── pmutil.c
│       ├── pmwin.c
│       ├── pmwinmm.c
│       ├── portmidi.c
│       ├── porttime.c
│       ├── ptlinux.c
│       ├── ptmacosx_cf.c
│       ├── ptmacosx_mach.c
│       └── ptwinmm.c
├── seq_qt5/
│   ├── Makefile.am
│   ├── README
│   ├── forms/
│   │   ├── Makefile.am
│   │   ├── qlfoframe.ui
│   │   ├── qliveframeex.ui
│   │   ├── qmutemaster.ui
│   │   ├── qpatternfix.ui
│   │   ├── qperfeditex.ui
│   │   ├── qperfeditframe64.ui
│   │   ├── qplaylistframe.ui
│   │   ├── qsabout.ui
│   │   ├── qsappinfo.ui
│   │   ├── qsbuildinfo.ui
│   │   ├── qseditoptions.ui
│   │   ├── qseqeditex.ui
│   │   ├── qseqeditframe64.ui
│   │   ├── qseqeventframe.ui
│   │   ├── qsessionframe.ui
│   │   ├── qsetmaster.ui
│   │   ├── qslivegrid.ui
│   │   ├── qslogview.ui
│   │   └── qsmainwnd.ui
│   ├── include/
│   │   ├── Makefile.am
│   │   ├── gui_palette_qt5.hpp
│   │   ├── palettefile.hpp
│   │   ├── qbase.hpp
│   │   ├── qclocklayout.hpp
│   │   ├── qeditbase.hpp
│   │   ├── qinputcheckbox.hpp
│   │   ├── qlfoframe.hpp
│   │   ├── qliveframeex.hpp
│   │   ├── qloopbutton.hpp
│   │   ├── qmutemaster.hpp
│   │   ├── qpatternfix.hpp
│   │   ├── qperfbase.hpp
│   │   ├── qperfeditex.hpp
│   │   ├── qperfeditframe64.hpp
│   │   ├── qperfnames.hpp
│   │   ├── qperfroll.hpp
│   │   ├── qperftime.hpp
│   │   ├── qplaylistframe.hpp
│   │   ├── qportwidget.hpp
│   │   ├── qsabout.hpp
│   │   ├── qsappinfo.hpp
│   │   ├── qsbuildinfo.hpp
│   │   ├── qscrollmaster.h
│   │   ├── qscrollslave.h
│   │   ├── qseditoptions.hpp
│   │   ├── qseqbase.hpp
│   │   ├── qseqdata.hpp
│   │   ├── qseqeditex.hpp
│   │   ├── qseqeditframe64.hpp
│   │   ├── qseqeventframe.hpp
│   │   ├── qseqframe.hpp
│   │   ├── qseqkeys.hpp
│   │   ├── qseqroll.hpp
│   │   ├── qseqtime.hpp
│   │   ├── qsessionframe.hpp
│   │   ├── qsetmaster.hpp
│   │   ├── qseventslots.hpp
│   │   ├── qslivebase.hpp
│   │   ├── qslivegrid.hpp
│   │   ├── qslogview.hpp
│   │   ├── qslotbutton.hpp
│   │   ├── qsmaintime.hpp
│   │   ├── qsmainwnd.hpp
│   │   ├── qstriggereditor.hpp
│   │   ├── qt5_helper.h
│   │   ├── qt5_helpers.hpp
│   │   └── qt5nsmanager.hpp
│   ├── seq_qt5.pro
│   └── src/
│       ├── Makefile.am
│       ├── gui_palette_qt5.cpp
│       ├── palettefile.cpp
│       ├── qbase.cpp
│       ├── qclocklayout.cpp
│       ├── qeditbase.cpp
│       ├── qinputcheckbox.cpp
│       ├── qlfoframe.cpp
│       ├── qliveframeex.cpp
│       ├── qloopbutton.cpp
│       ├── qmutemaster.cpp
│       ├── qpatternfix.cpp
│       ├── qperfbase.cpp
│       ├── qperfeditex.cpp
│       ├── qperfeditframe64.cpp
│       ├── qperfnames.cpp
│       ├── qperfroll.cpp
│       ├── qperftime.cpp
│       ├── qplaylistframe.cpp
│       ├── qportwidget.cpp
│       ├── qsabout.cpp
│       ├── qsappinfo.cpp
│       ├── qsbuildinfo.cpp
│       ├── qscrollmaster.cpp
│       ├── qscrollslave.cpp
│       ├── qseditoptions.cpp
│       ├── qseqbase.cpp
│       ├── qseqdata.cpp
│       ├── qseqeditex.cpp
│       ├── qseqeditframe64.cpp
│       ├── qseqeventframe.cpp
│       ├── qseqframe.cpp
│       ├── qseqkeys.cpp
│       ├── qseqroll.cpp
│       ├── qseqtime.cpp
│       ├── qsessionframe.cpp
│       ├── qsetmaster.cpp
│       ├── qseventslots.cpp
│       ├── qslivebase.cpp
│       ├── qslivegrid.cpp
│       ├── qslogview.cpp
│       ├── qslotbutton.cpp
│       ├── qsmaintime.cpp
│       ├── qsmainwnd.cpp
│       ├── qstriggereditor.cpp
│       ├── qt5_helpers.cpp
│       └── qt5nsmanager.cpp
└── seq_rtmidi/
    ├── Makefile.am
    ├── include/
    │   ├── Makefile.am
    │   ├── mastermidibus_rm.hpp
    │   ├── midi_alsa.hpp
    │   ├── midi_alsa_info.hpp
    │   ├── midi_api.hpp
    │   ├── midi_info.hpp
    │   ├── midi_jack.hpp
    │   ├── midi_jack_data.hpp
    │   ├── midi_jack_info.hpp
    │   ├── midi_probe.hpp
    │   ├── midibus_rm.hpp
    │   ├── rterror.hpp
    │   ├── rtmidi.hpp
    │   ├── rtmidi_info.hpp
    │   ├── rtmidi_types.hpp
    │   └── seq66_rtmidi_features.h
    ├── seq_rtmidi.pro
    └── src/
        ├── Makefile.am
        ├── mastermidibus.cpp
        ├── midi_alsa.cpp
        ├── midi_alsa_info.cpp
        ├── midi_api.cpp
        ├── midi_info.cpp
        ├── midi_jack.cpp
        ├── midi_jack_data.cpp
        ├── midi_jack_info.cpp
        ├── midi_probe.cpp
        ├── midibus.cpp
        ├── rtmidi.cpp
        ├── rtmidi_info.cpp
        └── rtmidi_types.cpp

SYMBOL INDEX (4675 symbols across 331 files)

FILE: Seq66cli/seq66rtcli.cpp
  function main (line 104) | int

FILE: Seq66qt5/seq66qt5.cpp
  function main (line 98) | int

FILE: contrib/code/affinity.cpp
  function main (line 8) | int

FILE: contrib/code/ametro.c
  type clock_type (line 96) | typedef enum
  function show_error (line 107) | static void
  function show_info (line 113) | static void
  function show_error_string (line 119) | static void
  function show_msg (line 125) | void
  function usage (line 131) | void
  function set_raw_mode (line 181) | void
  function kbcount (line 237) | int
  function quick_read (line 262) | int
  function bail_out (line 306) | void
  function handle_char (line 312) | int
  function open_sequencer (line 327) | void
  function subscribe (line 376) | void
  function create_queue (line 425) | void
  function set_tempo (line 436) | void
  function clear_queue (line 447) | void
  function start_queue (line 462) | void
  function stop_queue (line 471) | void
  function continue_queue (line 480) | void
  function make_note (line 493) | void
  function make_echo (line 508) | void
  function make_clock (line 522) | void
  function make_clock_event (line 537) | void
  function pattern (line 576) | void
  function set_program (line 614) | void
  function midi_action (line 636) | void
  function sigterm_exit (line 666) | void
  function check_range (line 677) | int
  function parse_options (line 688) | int
  function main (line 818) | int

FILE: contrib/code/function_calls_gnu.c
  function trace_begin (line 66) | void __attribute__ ((constructor))
  function trace_end (line 89) | void __attribute__ ((destructor))
  function __cyg_profile_func_enter (line 107) | void __attribute__((no_instrument_function))

FILE: contrib/code/qchannelpopup.cpp
  type seq66 (line 42) | namespace seq66

FILE: contrib/code/qchannelpopup.hpp
  class QComboBox (line 43) | class QComboBox
  type seq66 (line 49) | namespace seq66
    class sequence (line 52) | class sequence
    class qchannelpopup (line 60) | class qchannelpopup : public QObject
      method qchannelpopup (line 74) | qchannelpopup (const qchannelpopup &) = delete;
      method qchannelpopup (line 75) | qchannelpopup & operator = (const qchannelpopup &) = delete;
      method qchannelpopup (line 76) | qchannelpopup (qchannelpopup &&) = default;
      method qchannelpopup (line 77) | qchannelpopup & operator = (qchannelpopup &&) = default;
      method sequence (line 87) | sequence & track ()
      method sequence (line 92) | const sequence & track () const
      method QComboBox (line 97) | QComboBox * channel_combo ()
      method QComboBox (line 102) | const QComboBox * channel_combo () const
      method edit_channel (line 107) | int edit_channel () const
      method set_dirty (line 114) | void set_dirty ()

FILE: contrib/code/readbinaryplist.c
  function bplist_free_data (line 187) | void
  type cache_node (line 224) | typedef struct cache_struct
  type bplist_info_node (line 232) | typedef struct bplist_info
  function value_ptr (line 272) | value_ptr
  function value_set_integer (line 279) | void
  function value_set_real (line 286) | void
  function value_set_date (line 297) | void
  function value_set_ascii_string (line 304) | void
  function value_set_unicode_string (line 313) | void
  function value_set_uid (line 322) | void
  function value_set_data (line 334) | void
  function value_set_array (line 350) | void
  function value_set_dict (line 364) | void
  function value_ptr (line 375) | value_ptr
  function cache_insert (line 392) | void
  function dict_insert (line 406) | void
  function BOOL (line 416) | BOOL
  function value_ptr (line 425) | value_ptr
  function value_ptr (line 496) | value_ptr
  function value_ptr (line 518) | value_ptr
  function value_ptr (line 524) | value_ptr
  function convert_uint64 (line 535) | uint64_t
  function value_ptr (line 548) | value_ptr
  function value_ptr (line 632) | static value_ptr
  function read_sized_int (line 719) | static uint64_t
  function read_offset (line 738) | static uint64_t
  function BOOL (line 749) | static BOOL
  function value_ptr (line 785) | static value_ptr
  function value_ptr (line 812) | static value_ptr
  function value_ptr (line 832) | static value_ptr
  function value_ptr (line 884) | static value_ptr
  function bplist_get_a_size (line 912) | uint64_t
  function value_ptr (line 956) | static value_ptr
  function value_ptr (line 973) | static value_ptr
  function value_ptr (line 998) | static value_ptr
  function value_ptr (line 1031) | static value_ptr
  function value_ptr (line 1062) | static value_ptr
  function value_ptr (line 1127) | static value_ptr
  function value_ptr (line 1220) | value_ptr
  function value_ptr (line 1238) | value_ptr
  function plist_print (line 1275) | void

FILE: contrib/code/readbinaryplist.h
  type pldata_node (line 78) | typedef struct pldata_struct
  type array_node (line 85) | typedef struct array_struct
  type dict_node (line 96) | typedef struct dict_struct
  type value_node (line 108) | typedef struct value_struct

FILE: contrib/code/ring_buffer.hpp
  class ring_buffer (line 6) | class ring_buffer
    type ring_iterator (line 29) | struct ring_iterator
      method comparable (line 194) | bool comparable (const ring_iterator & other)
      method ring_iterator (line 201) | ring_iterator () :
      method ring_iterator (line 210) | ring_iterator (const ring_buffer<TYPE>::ring_iterator<false> & i) :
      method reference (line 219) | reference operator * ()
      method reference (line 228) | reference operator [] (size_type index)
      method pointer (line 235) | pointer operator->()
      method ring_iterator (line 240) | ring_iterator & operator ++ ()
      method ring_iterator (line 246) | ring_iterator operator ++ (int)
      method ring_iterator (line 253) | ring_iterator & operator -- ()
      method ring_iterator (line 259) | ring_iterator operator -- (int)
      method ring_iterator (line 266) | ring_iterator operator + (ring_iterator lhs, int rhs)
      method ring_iterator (line 272) | ring_iterator operator + (int lhs, ring_iterator rhs)
      method ring_iterator (line 278) | ring_iterator & operator += (int n)
      method ring_iterator (line 284) | ring_iterator operator - (ring_iterator lhs, int rhs)
      method difference_type (line 290) | difference_type operator -
      method ring_iterator (line 299) | ring_iterator & operator -= (int n)
    method ring_buffer (line 35) | ring_buffer (size_type sz = 8) :
    method ring_buffer (line 45) | ring_buffer (std::initializer_list<TYPE> lst) :
    method reference (line 56) | reference operator [] (size_type index)
    method const_reference (line 62) | const_reference operator [] (size_type index) const
    method reference (line 69) | reference at (size_type index)
    method const_reference (line 77) | const_reference at (size_type index) const
    method reference (line 104) | reference front ()
    method const_reference (line 109) | const_reference front () const
    method reference (line 114) | reference back ()
    method const_reference (line 119) | const_reference back () const
    method clear (line 124) | void clear ()
    method size_type (line 133) | size_type size () const
    method size_type (line 138) | size_type capacity () const
    method empty (line 143) | bool empty () const
    method full (line 148) | bool full () const
    method size_type (line 153) | size_type max_size () const
    class ring_iterator (line 166) | class ring_iterator
      method comparable (line 194) | bool comparable (const ring_iterator & other)
      method ring_iterator (line 201) | ring_iterator () :
      method ring_iterator (line 210) | ring_iterator (const ring_buffer<TYPE>::ring_iterator<false> & i) :
      method reference (line 219) | reference operator * ()
      method reference (line 228) | reference operator [] (size_type index)
      method pointer (line 235) | pointer operator->()
      method ring_iterator (line 240) | ring_iterator & operator ++ ()
      method ring_iterator (line 246) | ring_iterator operator ++ (int)
      method ring_iterator (line 253) | ring_iterator & operator -- ()
      method ring_iterator (line 259) | ring_iterator operator -- (int)
      method ring_iterator (line 266) | ring_iterator operator + (ring_iterator lhs, int rhs)
      method ring_iterator (line 272) | ring_iterator operator + (int lhs, ring_iterator rhs)
      method ring_iterator (line 278) | ring_iterator & operator += (int n)
      method ring_iterator (line 284) | ring_iterator operator - (ring_iterator lhs, int rhs)
      method difference_type (line 290) | difference_type operator -
      method ring_iterator (line 299) | ring_iterator & operator -= (int n)

FILE: contrib/code/test/filename_split.cpp
  function split_test (line 8) | static void
  function filename_split_tests (line 53) | static void

FILE: contrib/code/ttymidi.c
  type argp_option (line 54) | struct argp_option
  type arguments_t (line 66) | typedef struct _arguments
  type jackdata_t (line 77) | typedef struct _jackdata
  function exit_cli (line 90) | void exit_cli(int sig)
  function error_t (line 99) | static error_t parse_opt (int key, char *arg, struct argp_state *state)
  function arg_set_defaults (line 146) | void arg_set_defaults(arguments_t *arguments)
  type argp (line 160) | struct argp
  function read_retry_or_error (line 166) | static inline uint8_t read_retry_or_error(int fd, void* dst)
  function write_retry_or_success (line 175) | static inline uint8_t write_retry_or_success(int fd, const void* src, ui...
  function process_client (line 206) | static int process_client(jack_nframes_t frames, void* ptr)
  function open_client (line 302) | bool open_client(jackdata_t* jackdata, jack_client_t* client)
  function close_client (line 384) | void close_client(jackdata_t* jackdata)
  type timeval (line 417) | struct timeval
  type termios2 (line 692) | struct termios2
  function _ttymidi_init (line 696) | static bool _ttymidi_init(bool exit_on_failure, jack_client_t* client)
  function _ttymidi_finish (line 822) | void _ttymidi_finish(void)
  function main (line 832) | int main(int argc, char** argv)
  function jack_initialize (line 852) | int jack_initialize(jack_client_t* client, const char* load_init)
  function jack_finish (line 881) | void jack_finish(void)

FILE: contrib/non/nsm.h
  type _nsm_client_t (line 99) | struct _nsm_client_t
  function NSM_EXPORT (line 140) | NSM_EXPORT
  function NSM_EXPORT (line 147) | NSM_EXPORT
  function NSM_EXPORT (line 154) | NSM_EXPORT
  function NSM_EXPORT (line 183) | NSM_EXPORT
  function NSM_EXPORT (line 191) | NSM_EXPORT
  function NSM_EXPORT (line 199) | NSM_EXPORT
  function NSM_EXPORT (line 207) | NSM_EXPORT
  function NSM_EXPORT (line 215) | NSM_EXPORT void
  function NSM_EXPORT (line 239) | NSM_EXPORT void
  function NSM_EXPORT (line 248) | NSM_EXPORT
  function NSM_EXPORT (line 256) | NSM_EXPORT
  function NSM_EXPORT (line 264) | NSM_EXPORT
  function NSM_EXPORT (line 272) | NSM_EXPORT
  function NSM_EXPORT (line 281) | NSM_EXPORT void
  function NSM_EXPORT (line 299) | NSM_EXPORT
  function NSM_EXPORT (line 307) | NSM_EXPORT
  function NSM_EXPORT (line 316) | NSM_EXPORT
  function NSM_EXPORT (line 324) | NSM_EXPORT
  function NSM_EXPORT (line 333) | NSM_EXPORT
  function NSM_EXPORT (line 355) | NSM_EXPORT int _nsm_osc_open ( const char *path, const char *types, lo_a...
  function NSM_EXPORT (line 383) | NSM_EXPORT int _nsm_osc_save ( const char *path, const char *types, lo_a...
  function NSM_EXPORT (line 410) | NSM_EXPORT int _nsm_osc_announce_reply ( const char *path, const char *t...
  function NSM_EXPORT (line 433) | NSM_EXPORT int _nsm_osc_error ( const char *path, const char *types, lo_...
  function NSM_EXPORT (line 455) | NSM_EXPORT int _nsm_osc_session_is_loaded ( const char *path, const char...
  function NSM_EXPORT (line 473) | NSM_EXPORT int _nsm_osc_broadcast ( const char *path, const char *types,...
  function NSM_EXPORT (line 489) | NSM_EXPORT
  function NSM_EXPORT (line 515) | NSM_EXPORT

FILE: libseq66/include/base64_images.hpp
  type seq66 (line 35) | namespace seq66

FILE: libseq66/include/cfg/basesettings.hpp
  type seq66 (line 43) | namespace seq66
    class basesettings (line 52) | class basesettings
      method basesettings (line 102) | basesettings (const basesettings & rhs) = default;
      method basesettings (line 103) | basesettings & operator = (const basesettings & rhs) = default;
      method is_modified (line 114) | bool is_modified () const
      method modify (line 119) | void modify ()
      method unmodify (line 124) | void unmodify ()
      method ordinal_version (line 129) | int ordinal_version () const
      method comments (line 134) | const comments & comments_block () const
      method comments (line 139) | comments & comments_block ()
      method is_error (line 151) | bool is_error () const
      method file_name (line 161) | void file_name (const std::string & fn)
      method ordinal_version (line 168) | void ordinal_version (int value)
      method increment_ordinal_version (line 173) | void increment_ordinal_version ()

FILE: libseq66/include/cfg/cmdlineopts.hpp
  type seq66 (line 54) | namespace seq66
    class rcsettings (line 57) | class rcsettings
    class cmdlineopts (line 63) | class cmdlineopts
      type option (line 69) | struct option
      method cmdlineopts (line 75) | cmdlineopts ()
      method cmdlineopts (line 80) | cmdlineopts (const cmdlineopts &) = default;
      method cmdlineopts (line 81) | cmdlineopts & operator = (const cmdlineopts &) = default;
      method cmdlineopts (line 82) | cmdlineopts (cmdlineopts &&) = default;
      method cmdlineopts (line 83) | cmdlineopts & operator = (cmdlineopts &&) = default;

FILE: libseq66/include/cfg/comments.hpp
  type seq66 (line 38) | namespace seq66
    class comments (line 45) | class comments
      method comments (line 68) | comments (const comments & rhs) = default;
      method comments (line 69) | comments & operator = (const comments & rhs) = default;
      method append (line 79) | void append (const std::string & line)
      method is_set (line 84) | bool is_set () const

FILE: libseq66/include/cfg/configfile.hpp
  type seq66 (line 44) | namespace seq66
    class rcsettings (line 46) | class rcsettings
    class configfile (line 65) | class configfile
      method configfile (line 194) | configfile () = delete;
      method configfile (line 195) | configfile (const configfile &) = delete;
      method configfile (line 196) | configfile & operator = (const configfile &) = delete;
      method name (line 224) | void name (const std::string & n)
      method version_number (line 234) | int version_number () const
      method file_version_number (line 244) | int file_version_number () const
      method bad_position (line 249) | bool bad_position (int p) const
      method line_position (line 254) | int line_position () const
      method is_error (line 264) | static bool is_error ()
      method is_default (line 269) | static bool is_default (int value)
      method is_missing (line 274) | static bool is_missing (int value)
      method is_default (line 279) | static bool is_default (float value)
      method is_missing (line 284) | static bool is_missing (float value)
      method file_version (line 304) | void file_version (const std::string & v)
      method version (line 310) | void version (const std::string & v)
      method version (line 316) | void version (int v)
      method rcsettings (line 321) | rcsettings & rc_ref ()
      method at_section_start (line 335) | bool at_section_start () const
      method line_number (line 352) | int line_number () const

FILE: libseq66/include/cfg/midicontrolfile.hpp
  type seq66 (line 45) | namespace seq66
    class midicontrolfile (line 54) | class midicontrolfile final : public configfile
      class key (line 64) | class key
        method category_name (line 76) | std::string category_name () const
        method slot_control (line 81) | int slot_control () const
      class stanza (line 88) | class stanza
        method category_code (line 103) | automation::category category_code () const
        method category_name (line 108) | std::string category_name () const
        method key_name (line 113) | std::string key_name () const
        method op_name (line 118) | std::string op_name () const
        method slot_number (line 123) | int slot_number () const
        method setting (line 128) | int setting (unsigned action, unsigned part) const
      method midicontrolfile (line 161) | midicontrolfile () = delete;
      method midicontrolfile (line 167) | midicontrolfile (const midicontrolfile &) = delete;
      method midicontrolfile (line 168) | midicontrolfile & operator = (const midicontrolfile &) = delete;
      method storage (line 214) | storage & stanzas ()

FILE: libseq66/include/cfg/mutegroupsfile.hpp
  type seq66 (line 39) | namespace seq66
    class mutegroups (line 42) | class mutegroups
    class mutegroupsfile (line 50) | class mutegroupsfile final : public configfile
      method mutegroupsfile (line 64) | mutegroupsfile () = delete;
      method mutegroupsfile (line 66) | mutegroupsfile (const mutegroupsfile &) = delete;
      method mutegroupsfile (line 67) | mutegroupsfile & operator = (const mutegroupsfile &) = delete;
      method mutegroups (line 82) | mutegroups & mutes ()
      method mutegroups (line 87) | const mutegroups & mutes () const

FILE: libseq66/include/cfg/notemapfile.hpp
  type seq66 (line 42) | namespace seq66
    class notemapfile (line 51) | class notemapfile final : public configfile
      method notemapfile (line 72) | notemapfile () = delete;
      method notemapfile (line 73) | notemapfile (const notemapfile &) = delete;
      method notemapfile (line 74) | notemapfile & operator = (const notemapfile &) = delete;
      method notemapper (line 87) | notemapper & mapper ()

FILE: libseq66/include/cfg/patchesfile.hpp
  type seq66 (line 42) | namespace seq66
    class patchesfile (line 51) | class patchesfile final : public configfile
      method patchesfile (line 72) | patchesfile () = delete;
      method patchesfile (line 73) | patchesfile (const patchesfile &) = delete;
      method patchesfile (line 74) | patchesfile & operator = (const patchesfile &) = delete;

FILE: libseq66/include/cfg/playlistfile.hpp
  type seq66 (line 37) | namespace seq66
    class playlist (line 40) | class playlist
    class playlistfile (line 47) | class playlistfile final : public configfile
      method playlistfile (line 77) | playlistfile () = delete;
      method playlistfile (line 78) | playlistfile (const playlistfile &) = delete;
      method playlistfile (line 79) | playlistfile & operator = (const playlistfile &) = delete;
      method playlist (line 98) | playlist & play_list()

FILE: libseq66/include/cfg/rcfile.hpp
  type seq66 (line 40) | namespace seq66
    class rcfile (line 49) | class rcfile final : public configfile
      method rcfile (line 60) | rcfile () = delete;
      method rcfile (line 62) | rcfile (const rcfile &) = delete;
      method rcfile (line 63) | rcfile & operator = (const rcfile &) = delete;

FILE: libseq66/include/cfg/rcsettings.hpp
  type seq66 (line 61) | namespace seq66
    type timebase (line 144) | enum class timebase
    type rsaction (line 169) | enum class rsaction
    class rcsettings (line 182) | class rcsettings final : public basesettings
      type interaction (line 193) | enum class interaction
      type setsmode (line 205) | enum class setsmode
      method rcsettings (line 654) | rcsettings (const rcsettings & rhs) = default;
      method rcsettings (line 655) | rcsettings & operator = (const rcsettings & rhs) = default;
      method no_name (line 658) | std::string no_name () const
      method files (line 685) | const files & config_files () const
      method clockslist (line 698) | const clockslist & clocks () const
      method clockslist (line 703) | clockslist & clocks ()
      method inputslist (line 708) | const inputslist & inputs () const
      method inputslist (line 713) | inputslist & inputs ()
      method metrosettings (line 718) | metrosettings & metro_settings ()
      method metrosettings (line 723) | const metrosettings & metro_settings () const
      method mute_group_save (line 728) | mutegroups::saving mute_group_save () const
      method keycontainer (line 733) | const keycontainer & key_controls () const
      method keycontainer (line 738) | keycontainer & key_controls ()
      method drop_empty_in_controls (line 743) | bool drop_empty_in_controls () const
      method bussbyte (line 748) | bussbyte midi_control_buss () const
      method midicontrolin (line 753) | const midicontrolin & midi_control_in () const
      method midicontrolin (line 758) | midicontrolin & midi_control_in ()
      method midicontrolout (line 763) | const midicontrolout & midi_control_out () const
      method midicontrolout (line 768) | midicontrolout & midi_control_out ()
      method get_clock_mod (line 773) | int get_clock_mod () const
      method verbose (line 778) | bool verbose () const
      method quiet (line 783) | bool quiet () const
      method investigate (line 788) | bool investigate () const
      method investigate_disabled (line 793) | bool investigate_disabled () const
      method alt_session (line 803) | bool alt_session () const
      method first_run_in_progress (line 808) | bool first_run_in_progress () const
      method auto_rc_save (line 815) | bool auto_rc_save () const
      method auto_usr_save (line 820) | bool auto_usr_save () const
      method auto_mutes_save (line 825) | bool auto_mutes_save () const
      method auto_playlist_save (line 830) | bool auto_playlist_save () const
      method auto_ctrl_save (line 842) | bool auto_ctrl_save () const
      method auto_drums_save (line 847) | bool auto_drums_save () const
      method auto_qss_save (line 857) | bool auto_qss_save () const
      method auto_palette_save (line 862) | bool auto_palette_save () const
      method save_old_triggers (line 867) | bool save_old_triggers () const
      method save_old_mutes (line 872) | bool save_old_mutes () const
      method allow_mod4_mode (line 877) | bool allow_mod4_mode () const
      method allow_snap_split (line 882) | bool allow_snap_split () const
      method allow_click_edit (line 887) | bool allow_click_edit () const
      method show_midi (line 892) | bool show_midi () const
      method priority (line 897) | bool priority () const
      method thread_priority (line 902) | int thread_priority () const
      method pass_sysex (line 907) | bool pass_sysex () const
      method with_jack_transport (line 912) | bool with_jack_transport () const
      method with_jack_master (line 917) | bool with_jack_master () const
      method with_jack_master_cond (line 922) | bool with_jack_master_cond () const
      method with_jack_midi (line 927) | bool with_jack_midi () const
      method with_alsa_midi (line 932) | bool with_alsa_midi () const
      method with_port_midi (line 937) | bool with_port_midi () const
      method jack_auto_connect (line 948) | bool jack_auto_connect () const
      method jack_use_offset (line 953) | bool jack_use_offset () const
      method jack_buffer_size (line 958) | int jack_buffer_size () const
      method song_start_mode (line 963) | bool song_start_mode () const
      method get_song_start_mode (line 968) | sequence::playback get_song_start_mode () const
      method song_start_auto (line 978) | bool song_start_auto () const
      method with_jack_transport (line 986) | void with_jack_transport (bool flag)
      method with_jack_master (line 991) | void with_jack_master (bool flag)
      method with_jack_master_cond (line 998) | void with_jack_master_cond (bool flag)
      method with_jack_midi (line 1005) | void with_jack_midi (bool flag)
      method with_alsa_midi (line 1010) | void with_alsa_midi (bool flag)
      method jack_auto_connect (line 1015) | void jack_auto_connect (bool flag)
      method jack_use_offset (line 1020) | void jack_use_offset (bool flag)
      method jack_buffer_size (line 1029) | void jack_buffer_size (int sz)
      method with_jack (line 1041) | bool with_jack () const
      method record_by_buss (line 1050) | bool record_by_buss () const
      method record_by_channel (line 1055) | bool record_by_channel () const
      method manual_ports (line 1060) | bool manual_ports () const
      method manual_auto_enable (line 1065) | bool manual_auto_enable () const
      method manual_port_count (line 1070) | int manual_port_count () const
      method manual_in_port_count (line 1075) | int manual_in_port_count () const
      method reveal_ports (line 1080) | bool reveal_ports () const
      method init_disabled_ports (line 1085) | bool init_disabled_ports () const
      method print_keys (line 1090) | bool print_keys () const
      method interaction (line 1099) | interaction interaction_method () const
      method setsmode (line 1104) | setsmode sets_mode () const
      method is_setsmode_normal (line 1109) | bool is_setsmode_normal () const
      method is_setsmode_autoarm (line 1114) | bool is_setsmode_autoarm () const
      method is_setsmode_additive (line 1119) | bool is_setsmode_additive () const
      method is_setsmode_allsets (line 1124) | bool is_setsmode_allsets () const
      method is_setsmode_clear (line 1129) | bool is_setsmode_clear () const
      method portname (line 1138) | portname port_naming () const
      method midi_filename (line 1151) | void midi_filename (const std::string & value)
      method clear_midi_filename (line 1156) | void clear_midi_filename ()
      method midi_filepath (line 1168) | void midi_filepath (const std::string & value)
      method rsaction (line 1176) | rsaction running_status_action () const
      method jack_session_active (line 1186) | bool jack_session_active () const
      method append_recent_file (line 1200) | bool append_recent_file (const std::string & filename)
      method remove_recent_file (line 1205) | bool remove_recent_file (const std::string & filename)
      method clear_recent_files (line 1210) | void clear_recent_files ()
      method load_most_recent (line 1215) | bool load_most_recent () const
      method full_recent_paths (line 1220) | bool full_recent_paths () const
      method portmaps_present (line 1225) | bool portmaps_present () const
      method portmaps_active (line 1230) | bool portmaps_active () const
      method playlist_active (line 1251) | bool playlist_active () const
      method notemap_active (line 1256) | bool notemap_active () const
      method patches_active (line 1261) | bool patches_active () const
      method palette_active (line 1266) | bool palette_active () const
      method style_sheet_active (line 1271) | bool style_sheet_active () const
      method user_file_active (line 1306) | bool user_file_active () const
      method use_midi_control_file (line 1316) | bool use_midi_control_file () const
      method midi_control_active (line 1321) | bool midi_control_active () const
      method mute_group_file_active (line 1331) | bool mute_group_file_active () const
      method use_mute_group_file (line 1341) | bool use_mute_group_file () const
      method application_name (line 1346) | const std::string application_name () const
      method tempo_track_number (line 1354) | int tempo_track_number () const
      method recent_file_count (line 1361) | int recent_file_count () const
      method recent_file_max (line 1366) | int recent_file_max () const
      method mute_group_save (line 1373) | void mute_group_save (mutegroups::saving ms)
      method drop_empty_in_controls (line 1378) | void drop_empty_in_controls (bool flag)
      method midi_control_buss (line 1383) | void midi_control_buss (bussbyte b)
      method set_clock_mod (line 1396) | void set_clock_mod (int clockmod)
      method session_tag (line 1402) | void session_tag (const std::string & t)
      method quiet (line 1407) | void quiet (bool flag)
      method first_run_in_progress (line 1420) | void first_run_in_progress (bool flag)
      method auto_usr_save (line 1427) | void auto_usr_save (bool flag)
      method auto_mutes_save (line 1432) | void auto_mutes_save (bool flag)
      method auto_playlist_save (line 1437) | void auto_playlist_save (bool flag)
      method auto_ctrl_save (line 1442) | void auto_ctrl_save (bool flag)
      method auto_drums_save (line 1451) | void auto_drums_save (bool flag)
      method auto_palette_save (line 1460) | void auto_palette_save (bool flag)
      method save_old_triggers (line 1472) | void save_old_triggers (bool flag)
      method save_old_mutes (line 1477) | void save_old_mutes (bool flag)
      method allow_mod4_mode (line 1482) | void allow_mod4_mode (bool /*flag*/)
      method allow_snap_split (line 1487) | void allow_snap_split (bool flag)
      method allow_click_edit (line 1492) | void allow_click_edit (bool flag)
      method show_midi (line 1497) | void show_midi (bool flag)
      method priority (line 1502) | void priority (bool flag)
      method thread_priority (line 1507) | void thread_priority (int p)
      method pass_sysex (line 1515) | void pass_sysex (bool flag)
      method song_start_mode (line 1520) | void song_start_mode (bool flag)
      method manual_ports (line 1530) | void manual_ports (bool flag)
      method manual_auto_enable (line 1535) | void  manual_auto_enable (bool flag)
      method manual_port_count (line 1540) | void manual_port_count (int count)
      method default_manual_port_counts (line 1548) | void default_manual_port_counts ()
      method manual_in_port_count (line 1554) | void manual_in_port_count (int count)
      method reveal_ports (line 1562) | void reveal_ports (bool flag)
      method init_disabled_ports (line 1567) | void init_disabled_ports (bool flag)
      method print_keys (line 1572) | void print_keys (bool flag)
      method midi_control_active (line 1577) | void midi_control_active (bool flag)
      method mute_group_file_active (line 1584) | void mute_group_file_active (bool flag)
      method playlist_active (line 1591) | void playlist_active (bool flag)
      method notemap_active (line 1596) | void notemap_active (bool flag)
      method patches_active (line 1601) | void patches_active (bool flag)
      method palette_active (line 1606) | void palette_active (bool flag)
      method style_sheet_active (line 1611) | void style_sheet_active (bool flag)
      method midi_base_directory (line 1616) | void  midi_base_directory (const std::string & mbd)
      method load_most_recent (line 1621) | void load_most_recent (bool f)
      method full_recent_paths (line 1626) | void full_recent_paths (bool f)
      method portmaps_present (line 1631) | void portmaps_present (bool f)
      method portmaps_active (line 1636) | void portmaps_active (bool f)
      method interaction_method (line 1641) | bool interaction_method (int v)
      method sets_mode (line 1646) | void sets_mode (setsmode sm)
      method jack_session_activate (line 1663) | void jack_session_activate ()
      method home_config_directory (line 1686) | void home_config_directory (const std::string & hcd)
      method user_file_active (line 1691) | void user_file_active (bool flag)

FILE: libseq66/include/cfg/recent.hpp
  type seq66 (line 38) | namespace seq66
    class recent (line 47) | class recent
      method recent (line 81) | recent (const recent & source) = default;
      method clear (line 85) | void clear ()
      method count (line 90) | int count () const
      method maximum (line 95) | int maximum () const

FILE: libseq66/include/cfg/scales.hpp
  type seq66 (line 46) | namespace seq66
    class eventlist (line 49) | class eventlist
    type keys (line 55) | enum class keys
    function legal_key (line 103) | inline bool
    function keys (line 109) | inline keys
    function key_to_int (line 115) | inline int
    function legal_note (line 121) | inline bool
    type scales (line 141) | enum class scales
    function legal_scale (line 177) | inline bool
    function scales (line 187) | inline scales
    function scale_to_int (line 193) | inline int
    type chords (line 203) | enum class chords
    function chords (line 214) | inline chords
    function chord_to_int (line 221) | inline int
    function legal_chord (line 227) | inline bool

FILE: libseq66/include/cfg/sessionfile.hpp
  type seq66 (line 38) | namespace seq66
    class sessionfile (line 45) | class sessionfile final : public configfile
      method sessionfile (line 67) | sessionfile () = delete;
      method sessionfile (line 68) | sessionfile (const sessionfile &) = delete;
      method sessionfile (line 69) | sessionfile & operator = (const sessionfile &) = delete;
      method write (line 74) | virtual bool write () override

FILE: libseq66/include/cfg/settings.hpp
  type seq66 (line 41) | namespace seq66
    class combolist (line 49) | class combolist
      method combolist (line 73) | combolist (const combolist &) = default;
      method combolist (line 74) | combolist & operator = (const combolist &) = default;
      method current (line 85) | std::string current () const
      method count (line 92) | int count () const
      method use_current (line 97) | bool use_current () const
      method add (line 102) | void add (const std::string & s)
      method add (line 107) | void add (int v)
    class rcsettings (line 122) | class rcsettings
    class usrsettings (line 123) | class usrsettings

FILE: libseq66/include/cfg/userinstrument.hpp
  type seq66 (line 40) | namespace seq66
    type userinstrument_t (line 67) | struct userinstrument_t
    class userinstrument (line 101) | class userinstrument
      method is_valid (line 135) | bool is_valid () const
      method controller_count (line 151) | int controller_count () const
      method controller_max (line 162) | int controller_max () const

FILE: libseq66/include/cfg/usermidibus.hpp
  type seq66 (line 42) | namespace seq66
    type usermidibus_t (line 52) | struct usermidibus_t
    class usermidibus (line 81) | class usermidibus
      method is_valid (line 118) | bool is_valid () const
      method channel_count (line 142) | int channel_count () const
      method channel_count (line 151) | void channel_count (int count)
      method channel_max (line 164) | int channel_max () const
      method set_name (line 181) | void set_name (const std::string & name)

FILE: libseq66/include/cfg/usrfile.hpp
  type seq66 (line 40) | namespace seq66
    class usrfile (line 59) | class usrfile final : public configfile
      method usrfile (line 66) | usrfile () = delete;
      method usrfile (line 67) | usrfile (const usrfile &) = delete;
      method usrfile (line 68) | usrfile & operator = (const usrfile &) = delete;

FILE: libseq66/include/cfg/usrsettings.hpp
  type seq66 (line 69) | namespace seq66
    type recordtempo (line 126) | enum class recordtempo
    type recordstyle (line 146) | enum class recordstyle
    type gridmode (line 161) | enum class gridmode
    type showkeys (line 182) | enum class showkeys
    class usrsettings (line 198) | class usrsettings final : public basesettings
      type option_bits (line 213) | enum option_bits
      type session (line 231) | enum class session
      method usrsettings (line 1058) | usrsettings (const usrsettings & rhs) = default;
      method usrsettings (line 1059) | usrsettings & operator = (const usrsettings & rhs) = default;
      method clear_buses_and_instruments (line 1074) | void clear_buses_and_instruments ()
      method usermidibus (line 1086) | const usermidibus & bus (int index) // const
      method userinstrument (line 1096) | const userinstrument & instrument (int index) // const
      method bus_count (line 1101) | int bus_count () const
      method bus_instrument (line 1108) | int bus_instrument (int buss, int channel)
      method instrument_count (line 1118) | int instrument_count () const
      method instrument_controller_active (line 1148) | bool instrument_controller_active (int instrum, int cc)
      method controller_active (line 1159) | bool controller_active (int buss, int channel, int cc)
      method window_scale (line 1185) | float window_scale () const
      method window_scale_x (line 1190) | float window_scale_x () const
      method window_scale_y (line 1195) | float window_scale_y () const
      method window_scaled_up (line 1213) | bool window_scaled_up () const
      method window_scaled_down (line 1224) | bool window_scaled_down () const
      method window_is_scaled (line 1233) | bool window_is_scaled () const
      method mainwnd_rows (line 1242) | int mainwnd_rows () const
      method mainwnd_cols (line 1247) | int mainwnd_cols () const
      method set_size (line 1252) | int set_size () const
      method set_offset (line 1257) | int set_offset (int setno) const
      method swap_coordinates (line 1262) | bool swap_coordinates () const
      method seqs_in_set (line 1273) | int seqs_in_set () const
      method gmute_tracks (line 1278) | int gmute_tracks () const
      method max_sequence (line 1283) | int max_sequence () const
      method total_seqs (line 1288) | int total_seqs () const
      method seqchars_x (line 1297) | int seqchars_x () const
      method seqchars_y (line 1306) | int seqchars_y () const
      method mainwnd_spacing (line 1311) | int mainwnd_spacing () const
      method base_zoom (line 1321) | int base_zoom () const
      method jitter_divisor (line 1329) | int jitter_divisor () const
      method jitter_divisor (line 1334) | void jitter_divisor (int d)
      method randomization_amount (line 1340) | int randomization_amount () const
      method randomization_amount (line 1345) | void randomization_amount (int r)
      method adapt_zoom (line 1357) | bool adapt_zoom () const
      method global_seq_feature (line 1362) | bool global_seq_feature () const
      method global_seq_feature (line 1367) | void global_seq_feature (bool flag)
      method seqedit_scale (line 1374) | int seqedit_scale () const
      method seqedit_scale (line 1379) | void seqedit_scale (int scale)
      method seqedit_key (line 1385) | int seqedit_key () const
      method seqedit_key (line 1390) | void seqedit_key (int key)
      method seqedit_bgsequence (line 1396) | int seqedit_bgsequence () const
      method seqedit_bgsequence (line 1408) | void seqedit_bgsequence (int seqnum)
      method progress_bar_thick (line 1413) | bool progress_bar_thick () const
      method progress_bar_thickness (line 1418) | int progress_bar_thickness () const
      method progress_box_elliptical (line 1423) | bool progress_box_elliptical () const
      method gridlines_thick (line 1428) | bool gridlines_thick () const
      method follow_progress (line 1433) | bool follow_progress () const
      method inverse_colors (line 1438) | bool inverse_colors () const
      method dark_theme (line 1448) | bool dark_theme () const
      method window_redraw_rate (line 1453) | int window_redraw_rate () const
      method test_option_bit (line 1460) | bool test_option_bit (int b)
      method set_option_bit (line 1465) | void set_option_bit (int b)
      method clear_option_bit (line 1470) | void clear_option_bit (int b)
      method clear_option_bits (line 1475) | void clear_option_bits ()
      method swap_coordinates (line 1483) | void swap_coordinates (bool flag)
      method convert_to_smf_1 (line 1515) | bool convert_to_smf_1 () const
      method convert_to_smf_1 (line 1520) | void convert_to_smf_1 (bool flag)
      method default_ppqn (line 1527) | int default_ppqn () const
      method use_default_ppqn (line 1532) | int use_default_ppqn () const
      method midi_ppqn (line 1540) | int midi_ppqn () const
      method use_file_ppqn (line 1545) | bool use_file_ppqn () const
      method file_ppqn (line 1550) | int file_ppqn () const
      method use_file_ppqn (line 1555) | void use_file_ppqn (bool flag)
      method file_ppqn (line 1560) | void file_ppqn (int p)
      method midi_beats_per_bar (line 1567) | int midi_beats_per_bar () const
      method midibpm (line 1572) | midibpm midi_bpm_minimum () const
      method midibpm (line 1577) | midibpm midi_beats_per_minute () const
      method midibpm (line 1582) | midibpm midi_bpm_maximum () const
      method midi_beat_width (line 1589) | int midi_beat_width () const
      method bussbyte (line 1594) | bussbyte midi_buss_override () const
      method is_buss_override (line 1599) | bool is_buss_override () const
      method velocity_override (line 1604) | short velocity_override () const
      method bpm_precision (line 1614) | int bpm_precision () const
      method midibpm (line 1619) | midibpm bpm_step_increment () const
      method midibpm (line 1624) | midibpm bpm_page_increment () const
      method auto_add_time_sig (line 1629) | bool auto_add_time_sig () const
      method min_zoom (line 1634) | int min_zoom () const
      method max_zoom (line 1639) | int max_zoom () const
      method option_daemonize (line 1653) | bool option_daemonize () const
      method save_daemonize (line 1658) | bool save_daemonize () const
      method option_use_logfile (line 1663) | bool option_use_logfile () const
      method key_height (line 1686) | int key_height () const
      method valid_key_height (line 1691) | bool valid_key_height (int h) const
      method showkeys (line 1696) | showkeys key_view () const
      method style_sheet_active (line 1705) | bool style_sheet_active () const
      method resume_note_ons (line 1717) | bool resume_note_ons () const
      method fingerprint_size (line 1722) | int fingerprint_size () const
      method progress_box_width (line 1727) | double progress_box_width () const
      method progress_box_height (line 1732) | double progress_box_height () const
      method progress_box_shown (line 1737) | bool progress_box_shown () const
      method progress_box_show_cc (line 1742) | bool progress_box_show_cc () const
      method progress_note_min (line 1747) | int progress_note_min () const
      method progress_note_max (line 1752) | int progress_note_max () const
      method lock_main_window (line 1757) | bool lock_main_window () const
      method session (line 1766) | session session_manager () const
      method want_no_session (line 1773) | bool want_no_session () const
      method want_nsm_session (line 1778) | bool want_nsm_session () const
      method want_jack_session (line 1783) | bool want_jack_session () const
      method in_nsm_session (line 1788) | bool in_nsm_session () const
      method session_visibility (line 1793) | bool session_visibility () const
      method escape_pattern (line 1807) | bool escape_pattern () const
      method pattern_armed (line 1812) | bool pattern_armed () const
      method pattern_thru (line 1817) | bool pattern_thru () const
      method pattern_record (line 1822) | bool pattern_record () const
      method pattern_alter_recording (line 1827) | bool pattern_alter_recording () const
      method alteration (line 1836) | alteration pattern_alteration () const
      method pattern_tighten (line 1848) | bool pattern_tighten () const
      method pattern_qrecord (line 1853) | bool pattern_qrecord () const
      method pattern_notemap (line 1858) | bool pattern_notemap () const
      method pattern_new_only (line 1863) | bool pattern_new_only () const
      method recordstyle (line 1875) | recordstyle pattern_record_style (int rs) const
      method recordstyle (line 1883) | recordstyle pattern_record_style () const
      method set_pattern_record_style (line 1891) | void set_pattern_record_style (recordstyle style)
      method pattern_record_code (line 1900) | int pattern_record_code (recordstyle rs) const
      method pattern_record_code (line 1905) | int pattern_record_code () const
      method pattern_wraparound (line 1910) | bool pattern_wraparound () const
      method alteration (line 1926) | alteration record_alteration () const
      method record_alteration (line 1931) | void record_alteration (alteration rm)
      method alter_recording (line 1937) | bool alter_recording () const
      method no_grid_record (line 1951) | bool no_grid_record () const
      method gridmode (line 1956) | gridmode grid_mode () const
      method gridmode (line 1961) | gridmode grid_mode (int gm) const
      method grid_mode_code (line 1966) | int grid_mode_code (gridmode gm) const
      method grid_mode_code (line 1971) | int grid_mode_code () const
      method enable_learn_confirmation (line 1978) | bool enable_learn_confirmation () const
      method enable_learn_confirmation (line 1983) | void enable_learn_confirmation (bool flag)
      method progress_bar_thick (line 1992) | void progress_bar_thick (bool flag)
      method progress_bar_thickness (line 1997) | void progress_bar_thickness (int t)
      method progress_box_elliptical (line 2002) | void progress_box_elliptical (bool flag)
      method follow_progress (line 2007) | void follow_progress (bool flag)
      method gridlines_thick (line 2012) | void gridlines_thick (bool flag)
      method lock_main_window (line 2017) | void lock_main_window (bool flag)
      method inverse_colors (line 2026) | void inverse_colors (bool flag)
      method time_fg_color (line 2035) | void time_fg_color (const std::string & fgc)
      method time_bg_color (line 2040) | void time_bg_color (const std::string & bgc)
      method dark_theme (line 2045) | void dark_theme (bool flag)
      method user_pdf_viewer (line 2070) | void user_pdf_viewer (const std::string & file)
      method user_browser (line 2075) | void user_browser (const std::string & file)
      method key_height (line 2080) | void key_height (int h)
      method style_sheet_active (line 2090) | void style_sheet_active (bool flag)
      method style_sheet (line 2095) | void style_sheet (const std::string & s)
      method resume_note_ons (line 2102) | void resume_note_ons (bool f)
      method progress_box_shown (line 2112) | void progress_box_shown (bool flag)
      method progress_box_show_cc (line 2117) | void progress_box_show_cc (bool flag)
      method in_nsm_session (line 2122) | void in_nsm_session (bool f)
      method session_visibility (line 2127) | void session_visibility (bool f)
      method session_url (line 2132) | void session_url (const std::string & value)
      method escape_pattern (line 2137) | void escape_pattern (bool flag)
      method pattern_armed (line 2142) | void pattern_armed (bool flag)
      method pattern_thru (line 2147) | void pattern_thru (bool flag)
      method pattern_record (line 2152) | void pattern_record (bool flag)
      method pattern_tighten (line 2157) | void pattern_tighten (bool flag)
      method pattern_qrecord (line 2162) | void pattern_qrecord (bool flag)
      method pattern_notemap (line 2167) | void pattern_notemap (bool flag)
      method pattern_new_only (line 2172) | void pattern_new_only (bool flag)
      method pattern_wraparound (line 2177) | void pattern_wraparound (bool flag)
      method grid_mode (line 2182) | void grid_mode (gridmode mode)
      method auto_add_time_sig (line 2195) | void auto_add_time_sig (bool f)

FILE: libseq66/include/cfg/zoomer.hpp
  type seq66 (line 38) | namespace seq66
    class zoomer (line 72) | class zoomer
      method change_zoom (line 153) | bool change_zoom (bool in)
      method zoom (line 158) | int zoom () const
      method base_zoom (line 163) | int base_zoom () const
      method scale (line 168) | int scale () const
      method ppqn (line 173) | int ppqn () const
      method scale_zoom (line 178) | int scale_zoom () const
      method expanded_zoom (line 183) | bool expanded_zoom () const
      method zoom_expansion (line 188) | int zoom_expansion () const
      method xoffset (line 196) | int xoffset (midipulse tick) const
      method pulses_per_pixel (line 206) | int pulses_per_pixel () const
      method pulses_per_substep (line 211) | int pulses_per_substep () const
      method pulses_per_partial_beat (line 228) | int pulses_per_partial_beat (int bpb = 4, int bw = 4) const
      method pulses_per_beat (line 234) | int pulses_per_beat (int bw = 4) const
      method pulses_per_bar (line 239) | int pulses_per_bar (int bpb = 4, int bw = 4) const

FILE: libseq66/include/ctrl/automation.hpp
  type seq66 (line 42) | namespace seq66
    type automation (line 45) | namespace automation
      type index (line 63) | enum index
      type category (line 97) | enum class category
      type action (line 135) | enum class action
      type slot (line 179) | enum class slot
      type ctrlstatus (line 358) | enum class ctrlstatus
      function ctrlstatus (line 441) | inline ctrlstatus
      function ctrlstatus (line 447) | inline ctrlstatus &
      function ctrlstatus (line 454) | inline ctrlstatus
      function ctrlstatus (line 460) | inline ctrlstatus &
      function ctrlstatus (line 467) | inline ctrlstatus
      function ctrlstatus (line 473) | inline ctrlstatus &
      function ctrlstatus (line 480) | inline ctrlstatus
      function ctrlstatus (line 486) | inline ctrlstatus
      function bit_test_or (line 498) | inline bool
      function bit_test_and (line 510) | inline bool
    function int_to_slot_cast (line 538) | inline automation::slot
    function slot_to_int_cast (line 544) | inline int
    function original_slot_count (line 550) | inline int
    function current_slot_count (line 556) | inline int
    function automation_action (line 566) | inline automation::action

FILE: libseq66/include/ctrl/keycontainer.hpp
  type seq66 (line 47) | namespace seq66
    class keycontainer (line 55) | class keycontainer
      method clear (line 178) | void clear ()
      method count (line 186) | int count () const
      method loaded_from_rc (line 201) | bool loaded_from_rc () const
      method loaded_from_rc (line 206) | void loaded_from_rc (bool flag)
      method use_auto_shift (line 211) | bool use_auto_shift () const
      method use_auto_shift (line 216) | void use_auto_shift (bool flag)
      method kbd_layout (line 221) | keyboard::layout kbd_layout () const
      method kbd_layout (line 226) | void kbd_layout (keyboard::layout lay)
      method kbd_layout_to_string (line 234) | std::string kbd_layout_to_string ()
      method keymap (line 249) | const keymap & container () const

FILE: libseq66/include/ctrl/keycontrol.hpp
  type seq66 (line 42) | namespace seq66
    class keycontrol (line 54) | class keycontrol : public opcontrol
      method keycontrol (line 114) | keycontrol () = default;
      method keycontrol (line 131) | keycontrol (const keycontrol &) = default;
      method keycontrol (line 132) | keycontrol & operator = (const keycontrol &) = default;
      method keycontrol (line 133) | keycontrol (keycontrol &&) = default;
      method keycontrol (line 134) | keycontrol & operator = (keycontrol &&) = default;
      method key_name (line 137) | std::string key_name () const
      method control_code (line 142) | int control_code () const
      method slot_control (line 153) | int slot_control () const
      method key_name (line 161) | void key_name (const std::string & kn)
      method label (line 171) | std::string label () const
      method ctrlkey (line 178) | ctrlkey ordinal () const
      method is_ctrl_ordinal (line 183) | bool is_ctrl_ordinal () const
      method ordinal (line 190) | void ordinal (ctrlkey ck)

FILE: libseq66/include/ctrl/keymap.hpp
  type seq66 (line 54) | namespace seq66
    type keyboard (line 57) | namespace keyboard
      type layout (line 66) | enum class layout
      type kmod_t (line 89) | enum kmod_t

FILE: libseq66/include/ctrl/keystroke.hpp
  type seq66 (line 42) | namespace seq66
    class keystroke (line 50) | class keystroke
      type action (line 60) | enum class action
      method keystroke (line 114) | keystroke () = default;
      method keystroke (line 121) | keystroke (const keystroke & rhs) = default;
      method keystroke (line 122) | keystroke & operator = (const keystroke & rhs) = default;
      method is_press (line 124) | bool is_press () const
      method is_good (line 131) | bool is_good () const
      method is (line 147) | bool is (ctrlkey ch) const
      method is (line 166) | bool is (ctrlkey ch1, ctrlkey ch2) const
      method is_left (line 175) | bool is_left () const
      method is_up (line 180) | bool is_up () const
      method is_right (line 185) | bool is_right () const
      method is_down (line 190) | bool is_down () const
      method is_menu (line 195) | bool is_menu () const
      method ctrlkey (line 200) | ctrlkey key () const
      method shift_lock (line 207) | void shift_lock ()
      method modifiers (line 212) | keyboard::modifiers modifiers () const
      method setmodifier (line 217) | void setmodifier (keyboard::modifiers km)
      method mod_control (line 226) | bool mod_control () const
      method mod_control_shift (line 235) | bool mod_control_shift () const
      method mod_super (line 244) | bool mod_super () const

FILE: libseq66/include/ctrl/midicontrol.hpp
  type seq66 (line 49) | namespace seq66
    class event (line 52) | class event
    class midicontrol (line 65) | class midicontrol : public keycontrol
      class key (line 79) | class key
        method key (line 91) | key () = default;
        method key (line 92) | key (const key &) = default;
        method key (line 93) | key & operator = (const key &) = default;
        method key (line 96) | key (midibyte status, midibyte d0) :
        method key (line 104) | key (const event & ev) :
        method bussbyte (line 118) | bussbyte buss () const
        method midibyte (line 123) | midibyte status () const
        method midibyte (line 128) | midibyte d0 () const
      method midicontrol (line 211) | midicontrol (const midicontrol &) = default;
      method midicontrol (line 212) | midicontrol & operator = (const midicontrol &) = default;
      method midicontrol (line 213) | midicontrol (midicontrol &&) = default;
      method midicontrol (line 214) | midicontrol & operator = (midicontrol &&) = default;
      method active (line 217) | bool active () const
      method inverse_active (line 222) | bool inverse_active () const
      method status (line 227) | int status () const
      method d0 (line 232) | int d0 () const
      method d1 (line 237) | int d1 () const
      method min_d1 (line 242) | int min_d1 () const
      method max_d1 (line 247) | int max_d1 () const
      method blank (line 256) | bool blank () const
      method match (line 277) | bool match (midibyte status, midibyte d0) const
      method in_range (line 289) | bool in_range (midibyte d1) const
      method key (line 296) | key make_key () const
        method key (line 91) | key () = default;
        method key (line 92) | key (const key &) = default;
        method key (line 93) | key & operator = (const key &) = default;
        method key (line 96) | key (midibyte status, midibyte d0) :
        method key (line 104) | key (const event & ev) :
        method bussbyte (line 118) | bussbyte buss () const
        method midibyte (line 123) | midibyte status () const
        method midibyte (line 128) | midibyte d0 () const

FILE: libseq66/include/ctrl/midicontrolbase.hpp
  type seq66 (line 43) | namespace seq66
    class midicontrolbase (line 51) | class midicontrolbase
      method bussbyte (line 147) | bussbyte nominal_buss () const
      method bussbyte (line 152) | bussbyte true_buss () const
      method bussbyte (line 157) | bussbyte configured_buss () const
      method is_blank (line 162) | bool is_blank () const
      method is_enabled (line 167) | bool is_enabled () const
      method is_disabled (line 172) | bool is_disabled () const
      method configure_enabled (line 177) | bool configure_enabled () const
      method offset (line 182) | int offset () const
      method rows (line 187) | int rows () const
      method columns (line 192) | int columns () const
      method nominal_buss (line 199) | void nominal_buss (bussbyte b)
      method true_buss (line 204) | void true_buss (bussbyte b)
      method configured_buss (line 212) | void configured_buss (bussbyte b)
      method is_blank (line 217) | void is_blank (bool flag)
      method is_enabled (line 222) | void is_enabled (bool flag)
      method configure_enabled (line 227) | void configure_enabled (bool flag)
      method offset (line 232) | void offset (int o)
      method rows (line 238) | void rows (int r)
      method columns (line 244) | void columns (int c)
    function bussbyte (line 264) | inline bussbyte
    function bussbyte (line 276) | inline bussbyte

FILE: libseq66/include/ctrl/midicontrolin.hpp
  type seq66 (line 47) | namespace seq66
    class keycontainer (line 50) | class keycontainer
    class midicontrolin (line 57) | class midicontrolin final : public midicontrolbase
      method midicontrolin (line 118) | midicontrolin (const midicontrolin &) = default;
      method midicontrolin (line 119) | midicontrolin & operator = (const midicontrolin &) = default;
      method midicontrolin (line 120) | midicontrolin (midicontrolin &&) = default;
      method midicontrolin (line 121) | midicontrolin & operator = (midicontrolin &&) = default;
      method comments (line 125) | comments & comments_block ()
      method comments (line 130) | const comments & comments_block () const
      method clear (line 135) | void clear ()
      method count (line 140) | int count () const
      method have_controls (line 145) | bool have_controls () const
      method mccontainer (line 150) | const mccontainer & container () const
      method inactive_allowed (line 160) | bool inactive_allowed () const
      method inactive_allowed (line 165) | void inactive_allowed (bool flag)
      method status (line 170) | automation::ctrlstatus status () const
      method is_status (line 175) | bool is_status () const
      method is_set (line 180) | bool is_set (automation::ctrlstatus status) const
      method is_replace (line 190) | bool is_replace () const
      method is_replace (line 195) | bool is_replace (automation::ctrlstatus status) const
      method is_snapshot (line 200) | bool is_snapshot () const
      method is_snapshot (line 205) | bool is_snapshot (automation::ctrlstatus status) const
      method is_queue (line 210) | bool is_queue () const
      method is_queue (line 215) | bool is_queue (automation::ctrlstatus status) const
      method is_keep_queue (line 220) | bool is_keep_queue () const
      method is_keep_queue (line 225) | bool is_keep_queue (automation::ctrlstatus status) const
      method is_oneshot (line 230) | bool is_oneshot () const
      method is_oneshot (line 235) | bool is_oneshot (automation::ctrlstatus status) const
      method is_learn (line 240) | bool is_learn () const
      method is_learn (line 245) | bool is_learn (automation::ctrlstatus status) const
      method is_solo (line 250) | bool is_solo () const
      method is_solo (line 255) | bool is_solo (automation::ctrlstatus status) const
      method add_status (line 260) | void add_status (automation::ctrlstatus status)
      method remove_status (line 265) | void remove_status (automation::ctrlstatus status)
      method clear_status (line 270) | void clear_status ()
      method remove_queued_replace (line 275) | void remove_queued_replace ()

FILE: libseq66/include/ctrl/midicontrolout.hpp
  type seq66 (line 48) | namespace seq66
    class performer (line 51) | class performer
    class midicontrolout (line 58) | class midicontrolout final : public midicontrolbase
      type seqaction (line 87) | enum class seqaction
      type uiaction (line 110) | enum class uiaction
      type index (line 163) | enum index
      type actionindex (line 216) | enum actionindex
      method midicontrolout (line 286) | midicontrolout (const midicontrolout &) = default;
      method midicontrolout (line 287) | midicontrolout & operator = (const midicontrolout &) = default;
      method seqaction_range (line 292) | static void seqaction_range (int & minimum, int & maximum)
      method set_master_bus (line 298) | void set_master_bus (mastermidibus * mmbus)
      method screenset_size (line 303) | int screenset_size () const
      method action_count (line 333) | int action_count () const
      method clear_macros (line 338) | void clear_macros ()
      method add_macro (line 343) | bool add_macro (const tokenization & tokens)
      method macro_count (line 348) | int macro_count () const
      method macros_active (line 353) | bool macros_active () const
      method macros_active (line 358) | void macros_active (bool flag)
      method expand_macros (line 363) | bool expand_macros ()
      method macro_lines (line 370) | std::string macro_lines () const
      method tokenization (line 375) | tokenization macro_names () const
      method midibytes (line 380) | midibytes macro_bytes (const std::string & name) const
      method midimacro (line 385) | const midimacro & macro (const std::string & name) const
      method macro_byte_strings (line 390) | std::string macro_byte_strings () const
      method make_macro_defaults (line 395) | bool make_macro_defaults ()

FILE: libseq66/include/ctrl/midimacro.hpp
  type seq66 (line 44) | namespace seq66
    class midimacro (line 52) | class midimacro
      method midimacro (line 107) | midimacro () = default;
      method midimacro (line 109) | midimacro (const midimacro &) = default;
      method midimacro (line 110) | midimacro & operator = (const midimacro &) = default;
      method midimacro (line 111) | midimacro (midimacro &&) = default;
      method midimacro (line 112) | midimacro & operator = (midimacro &&) = default;
      method tokenization (line 120) | tokenization tokens () const
      method event_count (line 129) | int event_count () const
      method is_valid (line 134) | bool is_valid () const
      method name (line 143) | void name (const std::string & n)
      method bytes (line 148) | void bytes (const midibytes & b)
      method push_bytes (line 153) | void push_bytes (const midibytes & b)

FILE: libseq66/include/ctrl/midimacros.hpp
  type seq66 (line 45) | namespace seq66
    class midimacros (line 53) | class midimacros
      method midimacros (line 86) | midimacros (const midimacros &) = default;
      method midimacros (line 87) | midimacros & operator = (const midimacros &) = default;
      method midimacros (line 88) | midimacros (midimacros &&) = default;
      method midimacros (line 89) | midimacros & operator = (midimacros &&) = default;
      method clear (line 92) | void clear ()
      method count (line 99) | int count () const
      method active (line 104) | bool active () const
      method active (line 109) | void active (bool flag)

FILE: libseq66/include/ctrl/midioperation.hpp
  type seq66 (line 47) | namespace seq66
    class midioperation (line 55) | class midioperation
      method midioperation (line 124) | midioperation (const midioperation &) = default;
      method midioperation (line 125) | midioperation & operator = (const midioperation &) = default;
      method midioperation (line 126) | midioperation (midioperation &&) = default;
      method midioperation (line 127) | midioperation & operator = (midioperation &&) = default;
      method is_usable (line 130) | bool is_usable () const
      method call (line 140) | bool call
      method cat_code (line 154) | automation::category cat_code () const
      method cat_name (line 159) | std::string cat_name () const
      method number (line 164) | automation::slot number () const
      method slot_name (line 169) | std::string slot_name () const

FILE: libseq66/include/ctrl/opcontainer.hpp
  type seq66 (line 70) | namespace seq66
    class opcontainer (line 78) | class opcontainer
      method opcontainer (line 112) | opcontainer (const opcontainer &) = default;
      method opcontainer (line 113) | opcontainer & operator = (const opcontainer &) = default;
      method opcontainer (line 114) | opcontainer (opcontainer &&) = default;
      method opcontainer (line 115) | opcontainer & operator = (opcontainer &&) = default;
      method clear (line 123) | void clear ()

FILE: libseq66/include/ctrl/opcontrol.hpp
  type seq66 (line 45) | namespace seq66
    class opcontrol (line 54) | class opcontrol
      method opcontrol (line 109) | opcontrol (const opcontrol &) = default;
      method opcontrol (line 110) | opcontrol & operator = (const opcontrol &) = default;
      method opcontrol (line 111) | opcontrol (opcontrol &&) = default;
      method opcontrol (line 112) | opcontrol & operator = (opcontrol &&) = default;
      method is_usable (line 120) | bool is_usable () const
      method is_glearn_control (line 130) | bool is_glearn_control () const                     /* a special cas...
      method allowed (line 144) | static bool allowed (int d0, bool inverse)
      method is_automation (line 153) | static bool is_automation (automation::category cat)
      method is_sequence_control (line 162) | static bool is_sequence_control (automation::category cat)
      method category_code (line 173) | automation::category category_code () const
      method category_name (line 178) | std::string category_name () const
      method action_code (line 183) | automation::action action_code () const
      method action_name (line 188) | std::string action_name () const
      method slot_number (line 193) | automation::slot slot_number () const
      method automation_slot_name (line 198) | std::string automation_slot_name () const

FILE: libseq66/include/midi/businfo.hpp
  type seq66 (line 48) | namespace seq66
    class event (line 50) | class event
    class midibus (line 51) | class midibus
    class businfo (line 60) | class businfo
      method businfo (line 98) | businfo () = delete;
      method remove (line 107) | void remove ()
      method midibus (line 113) | const midibus * bus () const
      method midibus (line 118) | midibus * bus ()
      method active (line 123) | bool active () const
      method initialized (line 130) | bool initialized () const
      method e_clock (line 135) | e_clock init_clock () const
      method init_input (line 140) | bool init_input () const
      method activate (line 147) | void activate ()
      method deactivate (line 152) | void deactivate ()
      method init_clock (line 157) | void init_clock (e_clock clocktype)
      method init_input (line 164) | void init_input (bool flag)
      method start (line 184) | void start ()
      method stop (line 189) | void stop ()
      method continue_from (line 194) | void continue_from (midipulse tick)
      method init_clock (line 199) | void init_clock (midipulse tick)
      method clock (line 204) | void clock (midipulse tick)
      method sysex (line 209) | void sysex (const event * ev)
    class busarray (line 224) | class busarray
      method count (line 245) | int count () const
      method midibus (line 250) | midibus * bus (bussbyte b)
      method client_id (line 255) | int client_id (bussbyte b)
      method start (line 265) | void start ()
      method stop (line 276) | void stop ()
      method continue_from (line 290) | void continue_from (midipulse tick)
      method init_clock (line 304) | void init_clock (midipulse tick)
      method clock (line 318) | void clock (midipulse tick)
      method set_all_clocks (line 334) | void set_all_clocks ()
      method set_all_inputs (line 356) | void set_all_inputs ()

FILE: libseq66/include/midi/calculations.hpp
  type seq66 (line 61) | namespace seq66
    type snapper (line 69) | enum class snapper
    type waveform (line 81) | enum class waveform
    function cast (line 94) | inline int
    function waveform (line 100) | inline waveform
    type lengthfix (line 111) | enum class lengthfix
    function cast (line 119) | inline int
    function lengthfix (line 125) | inline lengthfix
    type alteration (line 137) | enum class alteration
    function cast (line 150) | inline int
    function alteration (line 156) | inline alteration
    type fixeffect (line 166) | enum class fixeffect
    function bit_test (line 183) | inline bool
    function fixeffect (line 194) | inline fixeffect
    function tempo_us_from_bpm (line 304) | inline double
    function midibpm (line 324) | inline midibpm
    function midibpm (line 340) | inline midibpm
    function pulse_length_us (line 373) | inline double
    function delta_time_us_to_ticks (line 412) | inline double
    function ticks_to_delta_time_us (line 441) | inline double
    function midi_clock_beats_per_qn (line 464) | inline int
    function clock_ticks_from_ppqn (line 482) | inline int
    function double_ticks_from_ppqn (line 499) | inline double
    function qn_per_beat (line 510) | inline double
    function default_pulses_per_measure (line 532) | inline int
    function pulses_per_measure (line 542) | inline int
    function pulses_per_quarter_beat (line 553) | inline int
    function pulses_per_beat (line 574) | inline int
    function midipulse (line 645) | inline midipulse
    function ticks_to_measures (line 676) | inline int
    function ticks_to_beats (line 682) | inline int
    function INTTYPE (line 689) | INTTYPE snapped (snapper snaptype, int S, INTTYPE p)
    function pitch_value_absolute (line 749) | inline int
    function pitch_value (line 771) | inline int
    function pitch_value_scaled (line 786) | inline int

FILE: libseq66/include/midi/controllers.hpp
  type seq66 (line 39) | namespace seq66
    type cc (line 81) | enum class cc

FILE: libseq66/include/midi/drums.hpp
  type seq66 (line 38) | namespace seq66
    class drums (line 46) | class drums
      method drums (line 78) | drums () = default;
      method drums (line 79) | drums (const drums &) = delete;
      method drums (line 80) | const drums & operator = (const drums &) = delete;
      method container (line 83) | const container & drum_map () const
      method clear (line 88) | void clear ()
      method comments (line 102) | void comments (const std::string & c)
      method active (line 107) | bool active () const
      method activate (line 112) | void activate (bool flag = true)

FILE: libseq66/include/midi/editable_event.hpp
  type seq66 (line 42) | namespace seq66
    class editable_events (line 45) | class editable_events
    class editable_event (line 64) | class editable_event final : public event
      type subgroup (line 77) | enum class subgroup : midibyte
      method editable_event (line 297) | editable_event () = default;
      method editable_event (line 304) | editable_event (const editable_event & rhs) = default;
      method editable_event (line 305) | editable_event & operator = (const editable_event & rhs) = default;
      method midipulse (line 315) | midipulse link_time () const
      method link_time (line 320) | void link_time (midipulse lt)
      method subgroup (line 327) | subgroup category () const
      method midipulse (line 352) | midipulse timestamp () const
      method time_as_pulses (line 365) | std::string time_as_pulses ()
      method status_string (line 392) | std::string status_string () const
      method meta_string (line 397) | std::string meta_string () const
      method seqspec_string (line 402) | std::string seqspec_string () const
      method channel_string (line 407) | std::string channel_string () const
      method data_string (line 412) | std::string data_string () const
      method editable_events (line 429) | const editable_events * parent () const

FILE: libseq66/include/midi/editable_events.hpp
  type seq66 (line 43) | namespace seq66
    class sequence (line 46) | class sequence
    class editable_events (line 64) | class editable_events
      method midi_timing (line 137) | const midi_timing & timing () const
      method Events (line 147) | Events & events ()
      method Events (line 152) | const Events & events () const
      method iterator (line 157) | iterator begin ()
      method const_iterator (line 162) | const_iterator begin () const
      method iterator (line 167) | iterator end ()
      method const_iterator (line 172) | const_iterator end () const
      method editable_event (line 184) | static editable_event & dref (iterator ie)
      method editable_event (line 196) | static const editable_event & cdref (const_iterator ie)
      method count (line 207) | int count () const
      method empty (line 212) | bool empty () const
      method replace (line 227) | bool replace (iterator ie, const editable_event & e)
      method remove (line 240) | void remove (iterator ie)
      method clear (line 246) | void clear ()
      method sort (line 255) | void sort ()
      method iterator (line 268) | iterator current_event () const
      method is_valid_iterator (line 277) | bool is_valid_iterator (iterator & cit) const
      method sequence (line 287) | const sequence & track () const
      method sequence (line 292) | sequence & track ()
      method current_event (line 304) | void current_event (iterator cei)

FILE: libseq66/include/midi/event.hpp
  type seq66 (line 93) | namespace seq66
    class event (line 266) | class event
      class key (line 303) | class key
        method key (line 313) | key () = default;
        method key (line 318) | key (const key & ek) = default;
        method key (line 319) | key & operator = (const key & ek) = default;
      method set_input_bus (line 460) | void set_input_bus (bussbyte b)
      method bussbyte (line 466) | bussbyte input_bus () const
      method set_timestamp (line 471) | void set_timestamp (midipulse time)
      method midipulse (line 476) | midipulse timestamp () const
      method midibyte (line 481) | midibyte channel () const
      method match_channel (line 505) | bool match_channel (int channel) const
      method midibyte (line 510) | static midibyte mask_channel (midibyte m)
      method midibyte (line 515) | static midibyte mask_status (midibyte m)
      method is_status (line 528) | static bool is_status (midibyte m)
      method midibyte (line 538) | static midibyte normalized_status (midibyte status)
      method is_data (line 553) | static bool is_data (midibyte m)
      method is_system_msg (line 567) | static bool is_system_msg (midibyte m)
      method is_meta_msg (line 572) | static bool is_meta_msg (midibyte m)
      method is_ex_data_msg (line 577) | static bool is_ex_data_msg (midibyte m)
      method is_pitchbend_msg (line 582) | static bool is_pitchbend_msg (midibyte m)
      method is_controller_msg (line 587) | static bool is_controller_msg (midibyte m)
      method is_note_msg (line 606) | static bool is_note_msg (midibyte m)
      method is_strict_note_msg (line 622) | static bool is_strict_note_msg (midibyte m)
      method is_note_on_msg (line 627) | static bool is_note_on_msg (midibyte m)
      method is_playable_msg (line 638) | static bool is_playable_msg (midibyte m)
      method is_channel_msg (line 664) | static bool is_channel_msg (midibyte m)
      method is_one_byte_msg (line 683) | static bool is_one_byte_msg (midibyte m)
      method is_two_byte_msg (line 702) | static bool is_two_byte_msg (midibyte m)
      method is_note_off_velocity (line 723) | static bool is_note_off_velocity (midibyte status, midibyte vel)
      method is_program_change_msg (line 728) | static bool is_program_change_msg (midibyte m)
      method is_meta_status (line 738) | static bool is_meta_status (midibyte m)
      method is_meta_text_msg (line 748) | static bool is_meta_text_msg (midibyte m)
      method is_tempo_status (line 753) | static bool is_tempo_status (midibyte m)
      method is_time_signature_status (line 758) | static bool is_time_signature_status (midibyte m)
      method is_sysex_msg (line 767) | static bool is_sysex_msg (midibyte m)
      method is_desired_cc_or_not_cc (line 794) | static inline bool is_desired_cc_or_not_cc
      method is_system_common_msg (line 808) | static bool is_system_common_msg (midibyte m)
      method is_realtime_msg (line 819) | static bool is_realtime_msg (midibyte m)
      method is_sense_or_reset (line 828) | static bool is_sense_or_reset (midibyte m)
      method mod_timestamp (line 844) | void mod_timestamp (midipulse modtick)
      method midibyte (line 873) | midibyte get_status () const
      method midibyte (line 878) | midibyte normalized_status () const
      method midibyte (line 883) | midibyte get_status (midibyte channel) const
      method midibyte (line 888) | midibyte get_meta_status () const
      method valid_status (line 893) | bool valid_status () const
      method match_status (line 910) | bool match_status (midibyte status) const
      method set_data (line 926) | void set_data (midibyte d0, midibyte d1 = 0)
      method clear_data (line 942) | void clear_data ()
      method clear_link (line 947) | void clear_link ()
      method get_data (line 960) | void get_data (midibyte & d0) const
      method get_data (line 976) | void get_data (midibyte & d0, midibyte & d1) const
      method midibyte (line 986) | midibyte d0 () const
      method d0 (line 991) | void d0 (midibyte b)
      method midibyte (line 996) | midibyte d1 () const
      method d1 (line 1001) | void d1 (midibyte b)
      method increment_d0 (line 1011) | void increment_d0 ()
      method decrement_d0 (line 1021) | void decrement_d0 ()
      method increment_d1 (line 1031) | void increment_d1 ()
      method decrement_d1 (line 1041) | void decrement_d1 ()
      method reset_sysex (line 1061) | void reset_sysex ()
      method sysex (line 1066) | sysex & get_sysex ()
      method sysex (line 1071) | const sysex & get_sysex () const
      method midibyte (line 1076) | midibyte get_sysex (size_t i) const
      method sysex_size (line 1081) | int sysex_size () const
      method on_linkable (line 1090) | bool on_linkable () const
      method off_linkable (line 1095) | bool off_linkable () const
      method off_linkable (line 1112) | bool off_linkable (buffer::iterator & eoff) const
      method link (line 1126) | void link (iterator ev)
      method iterator (line 1132) | iterator link () const
      method is_linked (line 1137) | bool is_linked () const
      method is_note_on_linked (line 1142) | bool is_note_on_linked () const
      method is_note_off_linked (line 1147) | bool is_note_off_linked () const
      method is_note_unlinked (line 1152) | bool is_note_unlinked () const
      method unlink (line 1157) | void unlink ()
      method paint (line 1162) | void paint ()
      method unpaint (line 1167) | void unpaint ()
      method is_painted (line 1172) | bool is_painted () const
      method mark (line 1177) | void mark ()
      method unmark (line 1182) | void unmark ()
      method is_marked (line 1187) | bool is_marked () const
      method select (line 1192) | void select ()
      method unselect (line 1197) | void unselect ()
      method is_selected (line 1202) | bool is_selected () const
      method make_clock (line 1211) | void make_clock ()
      method midibyte (line 1216) | midibyte data (int index) const    /* index not checked, for speed */
      method midibyte (line 1226) | midibyte get_note () const
      method set_note (line 1239) | void set_note (midibyte note)
      method note_velocity (line 1254) | void note_velocity (int vel)
      method midibyte (line 1259) | midibyte note_velocity () const
      method is_note_on (line 1264) | bool is_note_on () const
      method is_note_off (line 1277) | bool is_note_off () const
      method is_note (line 1291) | bool is_note () const
      method is_strict_note (line 1296) | bool is_strict_note () const
      method is_selected_note (line 1301) | bool is_selected_note () const
      method is_selected_note_on (line 1306) | bool is_selected_note_on () const
      method is_controller (line 1311) | bool is_controller () const
      method is_pitchbend (line 1316) | bool is_pitchbend () const
      method is_playable (line 1321) | bool is_playable () const
      method is_selected_status (line 1326) | bool is_selected_status (midibyte status) const
      method is_note_off_recorded (line 1344) | bool is_note_off_recorded () const
      method is_midi_start (line 1349) | bool is_midi_start () const
      method is_midi_continue (line 1354) | bool is_midi_continue () const
      method is_midi_stop (line 1359) | bool is_midi_stop () const
      method is_midi_clock (line 1364) | bool is_midi_clock () const
      method is_midi_song_pos (line 1369) | bool is_midi_song_pos () const
      method has_channel (line 1374) | bool has_channel () const
      method is_one_byte (line 1385) | bool is_one_byte () const
      method is_two_bytes (line 1396) | bool is_two_bytes () const
      method is_program_change (line 1401) | bool is_program_change () const
      method is_continuous_event (line 1412) | bool is_continuous_event () const
      method is_sysex (line 1423) | bool is_sysex () const
      method below_sysex (line 1428) | bool below_sysex () const
      method is_sense_reset (line 1438) | bool is_sense_reset ()
      method is_meta (line 1449) | bool is_meta () const
      method is_meta_text (line 1458) | bool is_meta_text () const
      method is_ex_data (line 1468) | bool is_ex_data () const
      method is_system (line 1473) | bool is_system () const
      method is_tempo (line 1482) | bool is_tempo () const
      method is_time_signature (line 1496) | bool is_time_signature () const
      method is_key_signature (line 1506) | bool is_key_signature () const

FILE: libseq66/include/midi/eventlist.hpp
  type seq66 (line 86) | namespace seq66
    class eventlist (line 93) | class eventlist
      type edit (line 108) | enum class edit
      type select (line 134) | enum class select
      method begin (line 244) | event::iterator begin ()
      method cbegin (line 249) | event::const_iterator cbegin () const
      method end (line 254) | event::iterator end ()
      method cend (line 259) | event::const_iterator cend () const
      method count (line 270) | int count () const
      method empty (line 282) | bool empty () const
      method midipulse (line 287) | midipulse get_length () const
      method midipulse (line 292) | midipulse note_off_margin () const
      method is_modified (line 297) | bool is_modified () const
      method has_tempo (line 302) | bool has_tempo () const
      method has_time_signature (line 307) | bool has_time_signature () const
      method unmodify (line 318) | void unmodify ()
      method remove (line 336) | event::iterator remove (event::iterator ie)
      method event (line 354) | static event & dref (event::iterator ie)
      method event (line 366) | static const event & cdref (event::const_iterator ie)
      method set_length (line 501) | void set_length (midipulse len)
      method zero_len_correction (line 507) | void zero_len_correction (midipulse zlc)

FILE: libseq66/include/midi/jack_assistant.hpp
  type seq66 (line 74) | namespace seq66
    class performer (line 76) | class performer
    class jack_scratchpad (line 86) | class jack_scratchpad
    class jack_assistant (line 141) | class jack_assistant
      method performer (line 360) | performer & parent ()       /* getter needed for external callbacks....
      method performer (line 365) | const performer & parent () const
      method is_running (line 370) | bool is_running () const
      method is_master (line 375) | bool is_master () const
      method is_slave (line 380) | bool is_slave () const
      method no_transport (line 385) | bool no_transport () const
      method get_ppqn (line 390) | int get_ppqn () const
      method beat_width (line 395) | int beat_width () const
      method set_beat_width (line 400) | void set_beat_width (int bw)
      method beats_per_measure (line 405) | int beats_per_measure () const
      method set_beats_per_measure (line 410) | void set_beats_per_measure (int bpm)
      method midibpm (line 415) | midibpm get_beats_per_minute () const
      method jack_transport_state_t (line 422) | jack_transport_state_t transport_state () const
      method transport_not_starting (line 431) | bool transport_not_starting () const
      method transport_rolling_now (line 436) | bool transport_rolling_now () const
      method transport_stopped_now (line 445) | bool transport_stopped_now () const
      method set_ppqn (line 476) | void set_ppqn (int ppqn)
      method get_jack_tick (line 481) | double get_jack_tick () const
      method jack_position_t (line 486) | const jack_position_t & jack_pos () const
      method jack_position_t (line 491) | jack_position_t & jack_pos ()
      method toggle_jack_mode (line 496) | void toggle_jack_mode ()
      method set_jack_mode (line 501) | void set_jack_mode (bool mode)
      method get_jack_mode (line 511) | bool get_jack_mode () const
      method midipulse (line 516) | midipulse jack_stop_tick () const
      method jack_stop_tick (line 521) | void jack_stop_tick (long tick)
      method jack_nframes_t (line 526) | jack_nframes_t jack_frame_rate () const
      method get_follow_transport (line 531) | bool get_follow_transport () const
      method set_follow_transport (line 536) | void set_follow_transport (bool aset)
      method toggle_follow_transport (line 541) | void toggle_follow_transport ()
      method jack_client_t (line 546) | jack_client_t * client () const
      method set_jack_running (line 570) | void set_jack_running (bool flag)
      method tick_multiplier (line 588) | double tick_multiplier () const

FILE: libseq66/include/midi/mastermidibase.hpp
  type seq66 (line 46) | namespace seq66
    class event (line 48) | class event
    class midibus (line 49) | class midibus
    class sequence (line 50) | class sequence
    class mastermidibase (line 56) | class mastermidibase
      method mastermidibase (line 178) | mastermidibase () = delete;
      method init (line 194) | virtual void init (int ppqn, midibpm bpm)
      method client_id (line 201) | int client_id () const
      method get_num_out_buses (line 206) | int get_num_out_buses () const
      method get_num_in_buses (line 211) | int get_num_in_buses () const
      method record_by_buss (line 216) | bool record_by_buss () const
      method record_by_buss (line 221) | void record_by_buss (bool flag)
      method record_by_channel (line 226) | bool record_by_channel () const
      method record_by_channel (line 231) | void record_by_channel (bool flag)
      method midibpm (line 236) | midibpm get_beats_per_minute () const
      method get_ppqn (line 241) | int get_ppqn () const
      method is_dumping_input (line 246) | bool is_dumping_input () const
      method sequence (line 256) | sequence * get_sequence () const
      method set_midi_alias (line 277) | void set_midi_alias
      method get_midi_alias (line 288) | std::string get_midi_alias (bussbyte bus, midibase::io iotype) const
      method get_midi_event (line 307) | bool get_midi_event (event * in)
      method set_client_id (line 325) | void set_client_id (int id)
      method set_port_statuses (line 335) | void set_port_statuses (const clockslist & outs, const inputslist & ...
      method e_clock (line 345) | e_clock clock (bussbyte bus)
      method input (line 350) | bool input (bussbyte bus)
      method api_start (line 362) | virtual void api_start ()
      method api_continue_from (line 372) | virtual void api_continue_from (midipulse /* tick */)
      method api_init_clock (line 382) | virtual void api_init_clock (midipulse /* tick */)
      method api_stop (line 391) | virtual void api_stop ()
      method api_set_ppqn (line 400) | virtual void api_set_ppqn (int /* ppqn */)
      method api_set_beats_per_minute (line 410) | virtual void api_set_beats_per_minute (midibpm /* bpm */)
      method api_flush (line 419) | virtual void api_flush ()
      method api_clock (line 428) | virtual void api_clock ()
      method api_client_port_start (line 433) | virtual void api_client_port_start (int /* client */, int /* port */)

FILE: libseq66/include/midi/midi_splitter.hpp
  type seq66 (line 40) | namespace seq66
    class performer (line 42) | class performer
    class sequence (line 43) | class sequence
    class midi_splitter (line 49) | class midi_splitter
      method midi_splitter (line 89) | midi_splitter (const midi_splitter &) = delete;
      method midi_splitter (line 90) | midi_splitter & operator = (const midi_splitter &) = delete;
      method count (line 102) | int count () const

FILE: libseq66/include/midi/midi_vector.hpp
  type seq66 (line 45) | namespace seq66
    class midi_vector (line 52) | class midi_vector : public midi_vector_base
      method size (line 89) | virtual unsigned size () const
      method done (line 103) | virtual bool done () const
      method put (line 116) | virtual void put (midibyte b)
      method midibyte (line 130) | virtual midibyte get () const
      method clear (line 141) | virtual void clear ()

FILE: libseq66/include/midi/midi_vector_base.hpp
  type seq66 (line 42) | namespace seq66
    class event (line 44) | class event
    class performer (line 45) | class performer
    class sequence (line 46) | class sequence
    class trigger (line 47) | class trigger
    class midi_vector_base (line 93) | class midi_vector_base
      method done (line 140) | virtual bool done () const
      method sequence (line 177) | sequence & seq ()
      method position_reset (line 188) | unsigned position_reset () const
      method position (line 199) | unsigned position () const
      method position_increment (line 209) | void position_increment () const
      method add_byte (line 216) | void add_byte (midibyte b)

FILE: libseq66/include/midi/midibase.hpp
  type seq66 (line 45) | namespace seq66
    class event (line 47) | class event
    class midibase (line 53) | class midibase
      type io (line 74) | enum class io
      type port (line 89) | enum class port
      method bus_index (line 294) | int bus_index () const
      method client_id (line 299) | int client_id () const
      method bus_id (line 304) | int bus_id () const
      method port_id (line 309) | int port_id () const
      method ppqn (line 314) | int ppqn () const
      method midibpm (line 319) | midibpm bpm () const
      method match (line 328) | bool match (int bus, int port)
      method port (line 333) | port port_type () const
      method is_virtual_port (line 338) | bool is_virtual_port () const
      method is_virtual_port (line 351) | void is_virtual_port (bool flag)
      method io (line 357) | io io_type () const
      method is_input_port (line 362) | bool is_input_port () const
      method is_output_port (line 367) | bool is_output_port () const
      method is_input_port (line 372) | void is_input_port (bool flag)
      method is_system_port (line 377) | bool is_system_port () const
      method e_clock (line 385) | e_clock get_clock () const
      method port_enabled (line 390) | bool port_enabled () const                  /* replaces get_input() */
      method port_unavailable (line 395) | bool port_unavailable () const
      method clock_enabled (line 400) | bool clock_enabled () const
      method set_io_status (line 405) | void set_io_status (bool flag)
      method set_port_unavailable (line 410) | void set_port_unavailable ()
      method queue_number (line 415) | int queue_number () const
      method set_bus_id (line 427) | void set_bus_id (int id)
      method set_client_id (line 432) | void set_client_id (int id)
      method set_clock_mod (line 457) | static void set_clock_mod (int clockmod)
      method get_clock_mod (line 467) | static int get_clock_mod ()
      method get_midi_event (line 483) | bool get_midi_event (event * inev)
      method poll_for_midi (line 498) | int poll_for_midi ()
      method init_out (line 517) | bool init_out ()
      method init_in (line 522) | bool init_in ()
      method init_out_sub (line 527) | bool init_out_sub ()
      method init_in_sub (line 532) | bool init_in_sub ()
      method deinit_in (line 537) | bool deinit_in ()
      method deinit_out (line 542) | bool deinit_out ()
      method display_name (line 549) | void display_name (const std::string & name)
      method bus_name (line 554) | void bus_name (const std::string & name)
      method port_name (line 559) | void port_name (const std::string & name)
      method set_port_id (line 569) | void set_port_id (int id)
      method is_port_locked (line 574) | virtual bool is_port_locked () const
      method api_poll_for_midi (line 584) | virtual int api_poll_for_midi ()
      method api_get_midi_event (line 593) | virtual bool api_get_midi_event (event * inev)
      method api_init_in_sub (line 602) | virtual bool api_init_in_sub ()
      method api_init_out_sub (line 611) | virtual bool api_init_out_sub ()
      method api_deinit_out (line 620) | virtual bool api_deinit_out ()
      method api_deinit_in (line 625) | virtual bool api_deinit_in ()
      method api_sysex (line 638) | virtual void api_sysex (const event * /* e24 */)
      method api_flush (line 647) | virtual void api_flush ()

FILE: libseq66/include/midi/midibus_common.hpp
  type seq66 (line 37) | namespace seq66
    type e_clock (line 104) | enum class e_clock
    function e_clock (line 119) | inline e_clock
    function clock_to_int (line 126) | inline int
    function clocking_enabled (line 132) | inline bool
    function port_unavailable (line 138) | inline bool
    function port_disabled (line 144) | inline bool

FILE: libseq66/include/midi/midibytes.hpp
  type seq66 (line 71) | namespace seq66
    class midi_measures (line 262) | class midi_measures
      method clear (line 295) | void clear ()
      method measures (line 300) | int measures () const
      method measures (line 313) | void measures (int m)
      method beats (line 318) | int beats () const
      method beats (line 331) | void beats (int b)
      method divisions (line 336) | int divisions () const
      method divisions (line 349) | void divisions (int d)
    class midi_timing (line 369) | class midi_timing
      method midibpm (line 410) | midibpm beats_per_minute () const
      method beats_per_minute (line 423) | void beats_per_minute (midibpm b)
      method beats_per_measure (line 428) | int beats_per_measure () const
      method beats_per_measure (line 441) | void beats_per_measure (int b)
      method beat_width (line 446) | int beat_width () const
      method beat_width (line 459) | void beat_width (int bw)
      method ppqn (line 464) | int ppqn () const
      method ppqn (line 477) | void ppqn (int p)
    function is_null_midipulse (line 489) | inline bool
    function is_null_buss (line 501) | inline bool
    function bussbyte (line 507) | inline bussbyte
    function is_good_buss (line 513) | inline bool
    function is_valid_buss (line 519) | inline bool
    function is_good_busscount (line 525) | inline bool
    function is_good_data_byte (line 531) | inline bool
    function midibyte (line 537) | inline midibyte
    function midibyte (line 543) | inline midibyte
    function midibyte (line 549) | inline midibyte
    function midibyte (line 560) | inline midibyte
    function midibyte (line 572) | inline const midibyte *
    function is_null_channel (line 595) | inline bool
    function midibyte (line 601) | inline midibyte
    function is_good_channel (line 607) | inline bool
    function is_valid_channel (line 613) | inline bool
    function bad_id (line 619) | inline int
    function byte_height (line 643) | inline int
    function byte_value (line 657) | inline int
    function null_system_port_id (line 671) | inline uint32_t
    function is_null_system_port_id (line 677) | inline bool

FILE: libseq66/include/midi/midifile.hpp
  type seq66 (line 55) | namespace seq66
    class event (line 57) | class event
    class midi_splitter (line 58) | class midi_splitter
    class midi_vector (line 59) | class midi_vector
    class performer (line 60) | class performer
    class midifile (line 68) | class midifile
      type save_option (line 79) | enum class save_option
      method error_is_fatal (line 256) | bool error_is_fatal () const
      method ppqn (line 270) | int ppqn () const
      method file_ppqn (line 275) | int file_ppqn () const
      method ppqn_ratio (line 280) | double ppqn_ratio () const
      method scaled (line 285) | bool scaled () const
      method pos (line 294) | size_t pos ()
      method verify_mode (line 307) | bool verify_mode () const
      method clear_errors (line 312) | void clear_errors ()
      method ppqn (line 318) | void ppqn (int p)
      method file_ppqn (line 323) | void file_ppqn (int p)
      method ppqn_ratio (line 328) | void ppqn_ratio (double r)
      method scaled (line 333) | void scaled (bool flag)
      method at_end (line 345) | bool at_end () const
      method midibyte (line 400) | midibyte peek (size_t ahead = 0) const
      method skip (line 405) | void skip (size_t sz)                       /* compare to read_gap()...
      method back_up (line 410) | void back_up (size_t sz)
      method write_byte (line 431) | void write_byte (midibyte c)
      method seq_number_size (line 466) | long seq_number_size () const
      method track_end_size (line 476) | long track_end_size () const

FILE: libseq66/include/midi/patches.hpp
  type seq66 (line 38) | namespace seq66
    class patches (line 46) | class patches
      method patches (line 78) | patches () = default;
      method patches (line 79) | patches (const patches &) = delete;
      method patches (line 80) | const patches & operator = (const patches &) = delete;
      method container (line 83) | const container & patch_map () const
      method clear (line 88) | void clear ()
      method comments (line 102) | void comments (const std::string & c)
      method active (line 107) | bool active () const
      method activate (line 112) | void activate (bool flag = true)

FILE: libseq66/include/midi/wrkfile.hpp
  type seq66 (line 42) | namespace seq66
    class performer (line 44) | class performer
    class sequence (line 45) | class sequence
    class wrkfile (line 53) | class wrkfile : public midifile
      type RecTempo (line 58) | struct RecTempo
      class wrkfile_private (line 71) | class wrkfile_private
      method ibyte (line 210) | int ibyte (midibyte b) const
      method performer (line 215) | performer * perfp ()

FILE: libseq66/include/os/daemonize.hpp
  type d_flags_t (line 46) | enum d_flags_t
  type d_flags_t (line 63) | enum d_flags_t
  type daemonization (line 79) | enum class daemonization
  type seq66 (line 88) | namespace seq66

FILE: libseq66/include/os/shellexecute.hpp
  type seq66 (line 33) | namespace seq66

FILE: libseq66/include/os/timing.hpp
  type seq66 (line 40) | namespace seq66

FILE: libseq66/include/play/clockslist.hpp
  type seq66 (line 42) | namespace seq66
    class clockslist (line 50) | class clockslist final : public portslist
      method clockslist (line 56) | clockslist (bool isportmap = false) : portslist (isportmap)

FILE: libseq66/include/play/inputslist.hpp
  type seq66 (line 39) | namespace seq66
    class inputslist (line 47) | class inputslist final : public portslist
      method inputslist (line 53) | inputslist (bool isportmap = false) : portslist (isportmap)

FILE: libseq66/include/play/metro.hpp
  type seq66 (line 46) | namespace seq66
    class metrosettings (line 54) | class metrosettings
      method sanity_check (line 155) | bool sanity_check () const
      method bussbyte (line 160) | bussbyte buss () const
      method midibyte (line 165) | midibyte channel () const
      method bussbyte (line 170) | bussbyte recording_buss () const
      method bussbyte (line 175) | bussbyte thru_buss () const
      method midibyte (line 180) | midibyte thru_channel () const
      method beats_per_bar (line 185) | int beats_per_bar () const
      method beat_width (line 190) | int beat_width () const
      method midibyte (line 195) | midibyte main_patch () const
      method midibyte (line 200) | midibyte sub_patch () const
      method midibyte (line 205) | midibyte main_note () const
      method midibyte (line 210) | midibyte main_note_velocity () const
      method main_note_fraction (line 215) | float main_note_fraction () const
      method midipulse (line 220) | midipulse main_note_length () const
      method midibyte (line 225) | midibyte sub_note () const
      method midibyte (line 230) | midibyte sub_note_velocity () const
      method sub_note_fraction (line 235) | float sub_note_fraction () const
      method midipulse (line 240) | midipulse sub_note_length () const
      method count_in_active (line 245) | bool count_in_active () const
      method count_in_measures (line 250) | int count_in_measures () const
      method count_in_recording (line 255) | bool count_in_recording () const
      method recording_measures (line 260) | int recording_measures () const
      method expand_recording (line 265) | bool expand_recording () const
      method buss (line 272) | void buss (int b)
      method channel (line 278) | void channel (int ch)
      method recording_buss (line 284) | void recording_buss (int b)
      method thru_buss (line 290) | void thru_buss (int b)
      method thru_channel (line 296) | void thru_channel (int ch)
      method beats_per_bar (line 302) | void beats_per_bar (int bpb)
      method beat_width (line 312) | void beat_width (int bw)
      method main_patch (line 317) | void main_patch (int patch)
      method sub_patch (line 323) | void sub_patch (int patch)
      method main_note (line 329) | void main_note (int note)
      method main_note_velocity (line 335) | void main_note_velocity (int vel)
      method main_note_fraction (line 341) | void main_note_fraction (float fraction)
      method sub_note (line 347) | void sub_note (int note)
      method sub_note_velocity (line 353) | void sub_note_velocity (int vel)
      method sub_note_fraction (line 359) | void sub_note_fraction (float fraction)
      method count_in_active (line 365) | void count_in_active (bool flag)
      method count_in_measures (line 370) | void count_in_measures (int count)
      method count_in_recording (line 375) | void count_in_recording (bool flag)
      method recording_measures (line 380) | void recording_measures (int m)
    class metro (line 392) | class metro : public sequence
      method uninitialize (line 411) | virtual bool uninitialize ()
      method metrosettings (line 416) | metrosettings & settings ()
    class recorder (line 431) | class recorder final : public metro

FILE: libseq66/include/play/mutegroup.hpp
  type seq66 (line 48) | namespace seq66
    class mutegroup (line 59) | class mutegroup
      method mutegroup (line 180) | mutegroup (const mutegroup &) = default;
      method mutegroup (line 181) | mutegroup & operator = (const mutegroup &) = default;
      method mutegroup (line 182) | mutegroup (mutegroup &&) = default;
      method mutegroup (line 183) | mutegroup & operator = (mutegroup &&) = default;
      method none (line 191) | static bool none (number group)
      method number (line 200) | static number unassigned ()
      method invalidate (line 205) | void invalidate ()
      method valid (line 210) | bool valid () const
      method group_state (line 215) | bool group_state () const
      method group_state (line 220) | void group_state (bool f)
      method count (line 225) | int count () const
      method muted (line 234) | bool muted (int index) const
      method midibooleans (line 241) | const midibooleans & zeroes () const
      method midibooleans (line 247) | const midibooleans & get () const
      method name (line 257) | void name (const std::string & n)
      method number (line 262) | number group () const
      method rows (line 267) | int rows () const
      method columns (line 272) | int columns () const
      method swap_coordinates (line 277) | bool swap_coordinates () const

FILE: libseq66/include/play/mutegroups.hpp
  type seq66 (line 59) | namespace seq66
    class mutegroups (line 66) | class mutegroups final : public basesettings
      type action (line 75) | enum class action
      type saving (line 106) | enum class saving
      type loading (line 120) | enum class loading
      method mutegroups (line 334) | mutegroups (const mutegroups &) = default;
      method mutegroups (line 335) | mutegroups & operator = (const mutegroups &) = default;
      method mutegroups (line 336) | mutegroups (mutegroups &&) = default;
      method mutegroups (line 337) | mutegroups & operator = (mutegroups &&) = default;
      method Rows (line 340) | static int Rows ()
      method Columns (line 345) | static int Columns ()
      method Size (line 350) | static int Size ()
      method Swap (line 355) | static bool Swap ()
      method null_mute_group (line 360) | static int null_mute_group ()
      method name (line 374) | void name (const std::string & nm)
      method rows (line 380) | int rows () const
      method rows (line 385) | void rows (int r)
      method group_format_hex (line 390) | bool group_format_hex () const
      method columns (line 395) | int columns () const
      method columns (line 400) | void columns (int c)
      method count (line 405) | int count () const
      method empty (line 410) | bool empty () const
      method group_count (line 415) | int group_count () const
      method loaded_from_mutes (line 425) | bool loaded_from_mutes () const
      method group_format_hex (line 430) | void group_format_hex (bool flag)
      method loaded_from_mutes (line 435) | void loaded_from_mutes (bool flag)
      method saving (line 440) | saving group_save () const
      method group_save_to_mutes (line 450) | bool group_save_to_mutes () const
      method group_save_to_midi (line 458) | bool group_save_to_midi () const
      method saveable_to_midi (line 466) | bool saveable_to_midi () const
      method loading (line 471) | loading group_load () const
      method group_load_from_mutes (line 482) | bool group_load_from_mutes () const
      method group_load_from_midi (line 490) | bool group_load_from_midi () const
      method armed_count (line 520) | int armed_count (mutegroup::number gmute) const
      method group_name (line 532) | void group_name (mutegroup::number gmute, const std::string & n)
      method container (line 537) | container & list ()
      method container (line 542) | const container & list () const
      method group_event (line 547) | bool group_event () const
      method group_error (line 552) | bool group_error () const
      method group_mode (line 559) | bool group_mode () const
      method is_group_learn (line 564) | bool is_group_learn () const
      method group_selected (line 569) | mutegroup::number group_selected () const
      method group_valid (line 574) | bool group_valid () const
      method group_valid (line 579) | bool group_valid (int g) const
      method group_present (line 584) | bool group_present () const
      method set_group_present (line 589) | void set_group_present ()
      method clamp_group (line 605) | mutegroup::number clamp_group (mutegroup::number group) const
      method check_group (line 615) | bool check_group (mutegroup::number group) const
      method toggle_active_only (line 620) | bool toggle_active_only () const
      method legacy_mutes (line 625) | bool legacy_mutes () const
      method strip_empty (line 630) | bool strip_empty () const
      method group_event (line 640) | void group_event (bool flag)
      method group_error (line 645) | void group_error (bool flag)
      method legacy_mutes (line 650) | void legacy_mutes (bool flag)
      method toggle_active_only (line 655) | void toggle_active_only (bool flag)
      method toggle_group_mode (line 660) | void toggle_group_mode ()
      method strip_empty (line 665) | void strip_empty (bool flag)
      method group_selected (line 670) | void group_selected (mutegroup::number mg)
      method group_mode (line 676) | void group_mode (bool flag)

FILE: libseq66/include/play/notemapper.hpp
  type seq66 (line 66) | namespace seq66
    class notemapper (line 81) | class notemapper final : public basesettings
      class pair (line 110) | class pair
        method pair (line 165) | pair () = delete;
        method pair (line 173) | pair (const pair &) = default;
        method pair (line 174) | pair & operator = (const pair &) = default;
        method dev_value (line 177) | int dev_value () const
        method gm_value (line 182) | int gm_value () const
        method increment_count (line 197) | void increment_count ()
        method count (line 202) | int count () const
      type direction (line 220) | enum class direction
      method notemapper (line 340) | notemapper (const notemapper &) = default;
      method notemapper (line 341) | notemapper & operator = (const notemapper &) = default;
      method midibyte (line 346) | midibyte fast_convert (midibyte incoming) const
      method direction (line 354) | direction get_direction () const
      method mode (line 359) | bool mode () const
      method mode (line 364) | void mode (bool m)
      method active (line 379) | static bool active (int value)
      method active (line 397) | static bool active (int v1, int v2)
      method note_minimum (line 418) | int note_minimum () const
      method note_maximum (line 423) | int note_maximum () const
      method gm_channel (line 428) | int gm_channel () const
      method device_channel (line 433) | int device_channel () const
      method valid (line 438) | bool valid () const
      method map (line 443) | const map & list () const
      method map_reversed (line 448) | bool map_reversed () const
      method map_type (line 455) | void map_type (const std::string & mp)
      method map_reversed (line 460) | void map_reversed (bool flag)
      method gm_channel (line 465) | void gm_channel (int ch)

FILE: libseq66/include/play/performer.hpp
  type seq66 (line 65) | namespace seq66
    class keystroke (line 82) | class keystroke
    class notemapper (line 83) | class notemapper
    class rcsettings (line 84) | class rcsettings
    class usrsettings (line 85) | class usrsettings
    class performer (line 91) | class performer
      type ff_rw (line 132) | enum class ff_rw
      type change (line 148) | enum class change
      class synch (line 165) | class synch : public synchronizer
        method synch (line 174) | synch (performer & p) : synchronizer (), m_perf (p)
        method synch (line 179) | synch () = delete;
        method synch (line 180) | synch (const synch &) = delete;
        method synch (line 181) | synch & operator =(const synch &) = delete;
        method predicate (line 183) | virtual bool predicate () const override
      class callbacks (line 202) | class callbacks
        type index (line 227) | enum class index
        method callbacks (line 243) | callbacks (performer & p) : m_performer(p)
        method true_change (line 248) | static bool true_change (performer::change mod)
        method on_group_learn (line 262) | virtual bool on_group_learn (bool /* learning */)
        method on_group_learn_complete (line 267) | virtual bool on_group_learn_complete
        method on_mutes_change (line 275) | virtual bool on_mutes_change (mutegroup::number, performer::change)
        method on_set_change (line 280) | virtual bool on_set_change (screenset::number, performer::change)
        method on_sequence_change (line 285) | virtual bool on_sequence_change (seq::number, performer::change)
        method on_automation_change (line 290) | virtual bool on_automation_change (automation::slot)
        method on_ui_change (line 295) | virtual bool on_ui_change (seq::number)
        method on_trigger_change (line 300) | virtual bool on_trigger_change (seq::number, performer::change)
        method on_resolution_change (line 305) | virtual bool on_resolution_change
        method on_song_action (line 313) | virtual bool on_song_action (bool, playlist::action)
        method on_signal_action (line 319) | virtual bool on_signal_action (bool, playlist::action)
        method performer (line 325) | performer & cb_perf ()
        method performer (line 330) | const performer & cb_perf () const
      method performer (line 1123) | performer () = delete;
      method performer (line 1126) | performer (const performer &) = delete;
      method performer (line 1127) | performer & operator = (const performer &) = delete;
      method smf_format (line 1163) | int smf_format () const
      method smf_format (line 1168) | void smf_format (int value)
      method error_pending (line 1173) | bool error_pending () const
      method error_messages (line 1178) | std::string error_messages () const
      method modify (line 1196) | void modify ()
      method modification (line 1206) | bool modification (change ctype)
      method set_to_string (line 1221) | std::string set_to_string (screenset::number setno) const
      method sets_to_string (line 1226) | std::string sets_to_string () const
      method show_patterns (line 1231) | void show_patterns () const
      method playset (line 1243) | const playset & play_set () const
      method playset (line 1248) | playset & play_set ()
      method playlist_count (line 1262) | int playlist_count () const
      method song_count (line 1267) | int song_count () const
      method playlist_reset (line 1272) | bool playlist_reset (int listindex = 0)
      method remove_playlist (line 1290) | bool remove_playlist ()
      method playlist_show (line 1295) | void playlist_show ()
      method playlist_test (line 1301) | void playlist_test ()
      method playlist_filename (line 1307) | std::string playlist_filename () const
      method playlist_midi_base (line 1315) | std::string playlist_midi_base () const
      method playlist_midi_number (line 1321) | int playlist_midi_number () const
      method playlist_name (line 1327) | std::string playlist_name () const
      method playlist_active (line 1333) | bool playlist_active () const
      method playlist_auto_arm (line 1338) | bool playlist_auto_arm () const
      method playlist_auto_play (line 1343) | bool playlist_auto_play () const
      method playlist_auto_advance (line 1348) | bool playlist_auto_advance () const
      method playlist_auto_advance (line 1353) | void playlist_auto_advance (bool on)
      method playlist_loaded (line 1359) | bool playlist_loaded () const
      method playlist_loaded (line 1364) | void playlist_loaded (bool on)
      method file_directory (line 1377) | std::string file_directory () const
      method song_directory (line 1383) | std::string song_directory () const
      method is_own_song_directory (line 1389) | bool is_own_song_directory () const
      method song_filename (line 1395) | std::string song_filename () const
      method song_filepath (line 1401) | std::string song_filepath () const
      method song_midi_number (line 1407) | int song_midi_number () const
      method playlist_song (line 1412) | std::string playlist_song () const
      method open_select_list_by_index (line 1420) | bool open_select_list_by_index (int index, bool opensong = true)
      method open_select_list_by_midi (line 1426) | bool open_select_list_by_midi (int ctrl, bool opensong = true)
      method add_list (line 1432) | bool add_list
      method modify_list (line 1442) | bool modify_list
      method remove_list (line 1452) | bool remove_list (int index)
      method add_song (line 1457) | bool add_song
      method add_song (line 1467) | bool add_song (const std::string & fullpath)
      method modify_song (line 1472) | bool modify_song
      method remove_song_by_index (line 1482) | bool remove_song_by_index (int index)
      method next_available_song_number (line 1497) | int next_available_song_number () const
      method next_available_list_number (line 1502) | int next_available_list_number () const
      method setmapper (line 1518) | setmapper & set_mapper ()
      method setmapper (line 1523) | const setmapper & set_mapper () const
      method setmaster (line 1528) | setmaster & set_master ()
      method setmaster (line 1533) | const setmaster & set_master () const
      method screenset_count (line 1542) | int screenset_count () const
      method screenset_active_count (line 1547) | int screenset_active_count () const
      method highest_set (line 1552) | int highest_set () const
      method screenset_max (line 1557) | int screenset_max () const
      method screenset_index (line 1562) | int screenset_index (screenset::number setno) const
      method screenset_size (line 1567) | int screenset_size () const
      method sequences_in_sets (line 1572) | int sequences_in_sets () const
      method ppqn (line 1577) | int ppqn () const
      method ppqn (line 1582) | void ppqn (int p)
      method midibpm (line 1592) | midibpm bpm () const
      method rows (line 1597) | int rows () const
      method columns (line 1602) | int columns () const
      method mute_rows (line 1607) | int mute_rows () const
      method mute_columns (line 1612) | int mute_columns () const
      method mute_count (line 1617) | int mute_count () const
      method master_grid_to_set (line 1622) | screenset::number master_grid_to_set (int row, int column) const
      method master_index_to_grid (line 1627) | bool master_index_to_grid
      method master_inside_set (line 1635) | bool master_inside_set (int row, int column) const
      method grid_to_seq (line 1640) | seq::number grid_to_seq (int row, int column) const
      method grid_to_seq (line 1645) | seq::number grid_to_seq
      method seq_to_grid (line 1654) | bool seq_to_grid
      method index_to_grid (line 1664) | bool index_to_grid (seq::number seqno, int & row, int & column) const
      method grid_to_index (line 1669) | int grid_to_index (int row, int column) const
      method sequence_count (line 1681) | int sequence_count () const
      method sequence_high (line 1686) | seq::number sequence_high () const
      method sequence_max (line 1691) | seq::number sequence_max () const
      method get_beats_per_bar (line 1696) | int get_beats_per_bar () const
      method set_beats_per_bar (line 1706) | void set_beats_per_bar (int bpb)
      method get_beat_width (line 1721) | int get_beat_width () const
      method set_beat_length (line 1731) | void set_beat_length (int bl)
      method clocks_per_metronome (line 1746) | void clocks_per_metronome (int cpm)
      method clocks_per_metronome (line 1751) | int clocks_per_metronome () const
      method set_32nds_per_quarter (line 1756) | void set_32nds_per_quarter (int tpq)
      method get_32nds_per_quarter (line 1761) | int get_32nds_per_quarter () const
      method us_per_quarter_note (line 1766) | void us_per_quarter_note (long upqn)
      method us_per_quarter_note (line 1771) | long us_per_quarter_note () const
      method mastermidibus (line 1776) | mastermidibus * master_bus ()
      method mastermidibus (line 1781) | const mastermidibus * master_bus () const
      method client_id (line 1788) | int client_id () const
      method record_by_channel (line 1793) | void record_by_channel (bool flag)
      method record_by_channel (line 1800) | bool record_by_channel () const
      method record_by_buss (line 1805) | void record_by_buss (bool flag)
      method record_by_buss (line 1812) | bool record_by_buss () const
      method is_running (line 1826) | bool is_running () const
      method is_pattern_playing (line 1836) | bool is_pattern_playing () const
      method is_pattern_paused (line 1843) | bool is_pattern_paused () const
      method done (line 1848) | bool done () const
      method jack_scratchpad (line 1859) | jack_scratchpad & pad ()
      method jack_output (line 1865) | bool jack_output (jack_scratchpad & pad)
      method jack_output (line 1870) | bool jack_output (jack_scratchpad & /*pad*/)
      method is_jack_running (line 1882) | bool is_jack_running () const
      method is_jack_master (line 1896) | bool is_jack_master () const
      method is_jack_slave (line 1905) | bool is_jack_slave () const
      method no_jack_transport (line 1914) | bool no_jack_transport () const
      method jack_transport_not_starting (line 1923) | bool jack_transport_not_starting () const
      method start_jack (line 1936) | void start_jack ()
      method stop_jack (line 1943) | void stop_jack (bool rewind = false)
      method init_jack_transport (line 1960) | bool init_jack_transport ()
      method deinit_jack_transport (line 1980) | bool deinit_jack_transport ()
      method position_jack (line 1990) | void position_jack (bool songmode, midipulse tick)
      method position_jack (line 1995) | void position_jack (bool, midipulse) { /* no code */ }
      method toggle_jack_mode (line 2000) | void toggle_jack_mode ()
      method get_jack_mode (line 2007) | bool get_jack_mode () const
      method midipulse (line 2016) | midipulse jack_stop_tick () const
      method jack_set_ppqn (line 2027) | bool jack_set_ppqn (int p)
      method jack_stop_tick (line 2038) | void jack_stop_tick (midipulse tick)
      method jack_stop_tick (line 2043) | void jack_stop_tick (midipulse)
      method midipulse (line 2049) | midipulse get_jack_tick () const
      method set_jack_tick (line 2054) | void set_jack_tick (midipulse tick)
      method set_follow_transport (line 2060) | void set_follow_transport (bool flag)
      method set_follow_transport (line 2065) | void set_follow_transport (bool)
      method get_follow_transport (line 2071) | bool get_follow_transport () const
      method toggle_follow_transport (line 2080) | void toggle_follow_transport ()
      method follow_progress (line 2091) | bool follow_progress () const
      method jackless_song_mode (line 2106) | bool jackless_song_mode () const
      method song_mode (line 2113) | bool song_mode (sequence::playback p) const
      method live_mode (line 2118) | bool live_mode () const
      method song_mode (line 2123) | bool song_mode () const
      method live_mode (line 2128) | bool live_mode (sequence::playback p) const
      method song_start_mode (line 2133) | void song_start_mode (sequence::playback p)
      method song_start_mode (line 2143) | sequence::playback song_start_mode () const
      method song_mode (line 2150) | void song_mode (bool flag)
      method toggle_song_mode (line 2156) | bool toggle_song_mode ()
      method set_reposition (line 2165) | void set_reposition (bool postype = true)
      method ff_rw (line 2170) | ff_rw ff_rw_type ()
      method ff_rw_type (line 2175) | void ff_rw_type (ff_rw button_type)
      method rewind (line 2188) | void rewind (bool press)
      method fast_forward (line 2201) | void fast_forward (bool press)
      method box_selection_empty (line 2234) | bool box_selection_empty () const
      method box_selection_clear (line 2239) | void box_selection_clear ()
      method request_sequence (line 2262) | bool request_sequence (seq::number seqno = seq::unassigned())
      method can_paste (line 2285) | bool can_paste () const
      method is_seq_in_edit (line 2290) | bool is_seq_in_edit (int seqno) const
      method print_busses (line 2299) | void print_busses () const
      method unqueue_sequences (line 2314) | void unqueue_sequences (int hotseq)
      method midipulse (line 2329) | midipulse get_right_tick () const
      method set_last_ticks (line 2351) | void set_last_ticks (midipulse tick)
      method midipulse (line 2356) | midipulse get_left_tick () const
      method set_start_tick (line 2361) | void set_start_tick (midipulse tick)
      method midipulse (line 2366) | midipulse get_start_tick () const
      method left_right_size (line 2379) | double left_right_size () const
      method is_seq_active (line 2404) | bool is_seq_active (seq::number seqno) const
      method is_seq_empty (line 2409) | bool is_seq_empty (seq::number seqno) const
      method is_seq_recording (line 2414) | bool is_seq_recording (seq::number seqno) const
      method first_seq (line 2421) | seq::number first_seq () const
      method apply_song_transpose (line 2428) | void apply_song_transpose ()
      method set_transpose (line 2438) | void set_transpose (int t)
      method get_transpose (line 2444) | int get_transpose () const
      method midibpm (line 2457) | midibpm get_beats_per_minute () const
      method current_beats (line 2467) | int current_beats () const
      method delta_us (line 2472) | long delta_us () const
      method clear_current_beats (line 2477) | void clear_current_beats ()
      method load_mute_groups (line 2484) | bool load_mute_groups (bool bmidi, bool bmutes)
      method is_keep_queue (line 2502) | bool is_keep_queue () const
      method is_solo (line 2507) | bool is_solo () const
      method sequence_playing_on (line 2525) | void sequence_playing_on (seq::number seqno)
      method sequence_playing_off (line 2537) | void sequence_playing_off (seq::number seqno)
      method mute_all_tracks (line 2555) | void mute_all_tracks (bool flag = true)
      method toggle_all_tracks (line 2568) | void toggle_all_tracks ()
      method toggle_playing_tracks (line 2586) | void toggle_playing_tracks ()
      method any_group_unmutes (line 2592) | bool any_group_unmutes () const
      method start (line 2625) | void start ()
      method stop (line 2635) | void stop ()
      method save_queued (line 2646) | void save_queued (int repseq)
      method midipulse (line 2661) | midipulse get_tick () const
      method learn_toggle (line 2666) | void learn_toggle ()
      method count_mutes (line 2673) | int count_mutes (mutegroup::number group)
      method midibooleans (line 2678) | midibooleans get_mutes (mutegroup::number gmute) const
      method midibooleans (line 2683) | midibooleans get_active_groups () const
      method toggle_active_only (line 2702) | bool toggle_active_only () const
      method toggle_active_only (line 2707) | void toggle_active_only (bool flag)
      method playscreen_number (line 2721) | screenset::number playscreen_number () const
      method playscreen_offset (line 2726) | seq::number playscreen_offset () const
      method playscreen_active_count (line 2731) | int playscreen_active_count () const
      method empty (line 2745) | bool empty (seq::cref s) const
      method highlight (line 2750) | bool highlight (seq::cref s) const
      method is_smf_0 (line 2762) | bool is_smf_0 (seq::cref s) const
      method loop (line 2783) | seq::pointer loop (seq::number seqno)
      method loop (line 2792) | const seq::pointer loop (seq::number seqno) const
      method off_sequences (line 2797) | void off_sequences (seq::number seqno = seq::unassigned())
      method port_map_error (line 2823) | bool port_map_error () const
      method clear_port_map_error (line 2828) | void clear_port_map_error () const
      method set_clock (line 2846) | void set_clock (bussbyte bus, e_clock clocktype)
      method e_clock (line 2851) | e_clock get_clock (bussbyte bus) const
      method set_input (line 2861) | void set_input (bussbyte bus, bool inputing)
      method get_input (line 2866) | bool get_input (bussbyte bus) const
      method midipulse (line 2939) | midipulse get_max_timestamp () const
      method midipulse (line 2944) | midipulse get_max_trigger () const
      method is_exportable (line 2965) | bool is_exportable (seq::number seqno) const
      method is_dirty_main (line 2983) | bool is_dirty_main (seq::number seqno) const
      method is_dirty_edit (line 2988) | bool is_dirty_edit (seq::number seqno) const
      method is_dirty_perf (line 2993) | bool is_dirty_perf (seq::number seqno) const
      method is_dirty_names (line 2998) | bool is_dirty_names (seq::number seqno) const
      method midicontrolout (line 3021) | const midicontrolout & midi_control_out () const
      method midicontrolout (line 3026) | midicontrolout & midi_control_out ()
      method set_needs_update (line 3031) | void set_needs_update (bool flag = true)
      method send_seq_event (line 3036) | void send_seq_event (int seqno, midicontrolout::seqaction what)
      method send_macro (line 3041) | void send_macro (const std::string & name)
      method macros_active (line 3046) | bool macros_active () const
      method macros_active (line 3051) | void macros_active (bool flag)
      method tokenization (line 3056) | tokenization macro_names () const
      method midibytes (line 3061) | midibytes macro_bytes (const std::string & name) const
      method midimacro (line 3066) | const midimacro & get_macro (const std::string & name) const
      method exec_slot_function (line 3071) | bool exec_slot_function
      method exec_set_function (line 3080) | bool exec_set_function (screenset::sethandler s)
      method exec_set_function (line 3085) | bool exec_set_function (screenset::sethandler s, screenset::slothand...
      method toggle_sequences (line 3101) | bool toggle_sequences (seq::number seqno, bool isshiftkey)
      method song_recording (line 3112) | bool song_recording () const
      method song_record_snap (line 3117) | bool song_record_snap () const
      method midipulse (line 3122) | midipulse record_snap_length () const
      method alteration (line 3127) | alteration record_alteration () const
      method recordstyle (line 3132) | recordstyle record_style () const
      method resume_note_ons (line 3137) | bool resume_note_ons () const
      method resume_note_ons (line 3142) | void resume_note_ons (bool f)
      method select_triggers_in_range (line 3147) | void select_triggers_in_range
      method unselect_all_triggers (line 3159) | void unselect_all_triggers ()
      method looping (line 3166) | bool looping () const
      method looping (line 3171) | void looping (bool looping)
      method color (line 3182) | int color (seq::number seqno) const
      method have_undo (line 3189) | bool have_undo () const
      method set_have_undo (line 3201) | void set_have_undo (bool undo)
      method have_redo (line 3208) | bool have_redo () const
      method set_have_redo (line 3213) | void set_have_redo (bool redo)
      method have_current_seq (line 3222) | bool have_current_seq () const
      method edit_mode (line 3233) | sequence::editmode edit_mode (seq::number seqno) const
      method edit_mode (line 3245) | sequence::editmode edit_mode (seq::cref s) const
      method edit_mode (line 3263) | void edit_mode (seq::number seqno, sequence::editmode ed)
      method edit_mode (line 3270) | void edit_mode (seq::ref s, sequence::editmode ed)
      method current_screenset_name (line 3279) | std::string current_screenset_name () const
      method is_screenset_valid (line 3284) | bool is_screenset_valid (screenset::number setno) const
      method is_screenset_active (line 3300) | bool is_screenset_active (screenset::number setno)
      method is_screenset_available (line 3316) | bool is_screenset_available (screenset::number setno)
      method screenset_name (line 3321) | void screenset_name (const std::string & note)
      method set_name (line 3333) | std::string set_name (screenset::number setno) const
      method seq_in_playing_screen (line 3338) | bool seq_in_playing_screen (int seq)
      method song_record_snap (line 3345) | void song_record_snap (bool f)
      method toggle_record_snap (line 3350) | void toggle_record_snap ()
      method record_snap_length (line 3355) | void record_snap_length (midipulse snap)
      method group_selected (line 3360) | mutegroup::number group_selected () const
      method midi_mute_group_present (line 3365) | bool midi_mute_group_present () const
      method is_group_learn (line 3370) | bool is_group_learn () const
      method group_count (line 3375) | int group_count () const
      method group_event (line 3380) | bool group_event () const
      method group_error (line 3385) | bool group_error () const
      method group_mode (line 3397) | bool group_mode () const
      method group_mode (line 3402) | void group_mode (bool flag)
      method toggle_group_mode (line 3407) | void toggle_group_mode ()
      method hidden (line 3419) | void hidden (bool flag)                         /* only for GUI to c...
      method notemap_exists (line 3439) | bool notemap_exists () const
      method copy_triggers (line 3444) | void copy_triggers ()
      method collapse (line 3455) | void collapse ()
      method copy (line 3466) | void copy ()
      method expand (line 3476) | void expand ()
      method keycontainer (line 3485) | const keycontainer & key_controls () const
      method keycontainer (line 3490) | keycontainer & key_controls ()
      method lookup_slot_key (line 3504) | std::string lookup_slot_key (int seqno) const
      method lookup_mute_key (line 3509) | std::string lookup_mute_key (int mute_number) const
      method midicontrolin (line 3514) | const midicontrolin & midi_control_in () const
      method midicontrolin (line 3519) | midicontrolin & midi_control_in ()
      method ctrl_status (line 3524) | automation::ctrlstatus ctrl_status () const
      method has_ctrl_status (line 3529) | bool has_ctrl_status () const
      method ctrl_status_string (line 3534) | std::string ctrl_status_string () const
      method mutegroup_count (line 3543) | int mutegroup_count () const
      method group_name (line 3548) | std::string group_name (mutegroup::number group) const
      method group_format_hex (line 3559) | bool group_format_hex () const
      method group_save_to_midi (line 3567) | bool group_save_to_midi () const
      method group_load_from_midi (line 3572) | bool group_load_from_midi () const
      method group_load_from_mutes (line 3577) | bool group_load_from_mutes () const
      method group_save_to_mutes (line 3582) | bool group_save_to_mutes () const
      method strip_empty (line 3587) | bool strip_empty () const
      method mutegroups (line 3594) | const mutegroups & mutes () const
      method mutegroups (line 3599) | mutegroups & mutes ()
      method reset_mute_groups (line 3611) | bool reset_mute_groups ()                       /* see clear_mutes()...
      method clear_snapshot (line 3618) | void clear_snapshot ()
      method save_snapshot (line 3623) | void save_snapshot ()
      method restore_snapshot (line 3628) | void restore_snapshot ()
      method is_running (line 3633) | void is_running (bool flag)
      method synch (line 3654) | synch & cv ()
        method synch (line 174) | synch (performer & p) : synchronizer (), m_perf (p)
        method synch (line 179) | synch () = delete;
        method synch (line 180) | synch (const synch &) = delete;
        method synch (line 181) | synch & operator =(const synch &) = delete;
        method predicate (line 183) | virtual bool predicate () const override
      method changed (line 3670) | static bool changed (change mod)
      method signalled_changes (line 3677) | bool signalled_changes () const
      method seq_edit_pending (line 3687) | bool seq_edit_pending () const
      method event_edit_pending (line 3692) | bool event_edit_pending () const
      method record_toggle_pending (line 3697) | bool record_toggle_pending () const
      method call_seq_edits (line 3702) | bool call_seq_edits () const
      method pending_loop (line 3708) | seq::number pending_loop () const
      method pending_loop (line 3713) | void pending_loop (seq::number n) const
      method slot_shift (line 3718) | int slot_shift () const
      method hidden (line 3726) | bool hidden () const
      method show_hide_pending (line 3731) | bool show_hide_pending () const
      method got_seqno (line 3740) | bool got_seqno (seq::number & s) const

FILE: libseq66/include/play/playlist.hpp
  type seq66 (line 42) | namespace seq66
    class performer (line 44) | class performer
    class playlist (line 52) | class playlist final : public basesettings
      type action (line 61) | enum class action
      type song_spec_t (line 79) | struct song_spec_t
      type play_list_t (line 132) | struct play_list_t
      method playlist (line 303) | playlist () = delete;
      method playlist (line 304) | playlist (const playlist &) = delete;
      method playlist (line 305) | playlist & operator = (const playlist &) = delete;
      method playlist (line 306) | playlist (playlist &&) = default;
      method playlist (line 307) | playlist & operator = (playlist &&) = default;
      method action_to_int (line 310) | static int action_to_int (action a)
      method action (line 315) | static action int_to_action (int i)
      method loaded (line 324) | bool loaded () const
      method loaded (line 329) | void loaded (bool m)
      method deep_verify (line 338) | bool deep_verify () const
      method deep_verify (line 343) | void deep_verify (bool flag)
      method auto_arm (line 354) | bool auto_arm () const
      method auto_arm (line 359) | void auto_arm (bool flag)
      method auto_play (line 364) | bool auto_play () const
      method auto_play (line 369) | void auto_play (bool flag)
      method engage_auto_play (line 374) | bool engage_auto_play () const
      method engage_auto_play (line 379) | void engage_auto_play (bool flag)
      method auto_play_engaged (line 384) | bool auto_play_engaged () const
      method reengage_auto_play (line 389) | void reengage_auto_play ()
      method disengage_auto_play (line 395) | void disengage_auto_play ()
      method auto_advance (line 401) | bool auto_advance () const
      method auto_advance_engaged (line 406) | bool auto_advance_engaged () const
      method auto_advance (line 411) | void auto_advance (bool flag)
      method list_midi_number (line 423) | int list_midi_number () const
      method list_index (line 429) | int list_index () const
      method list_name (line 435) | std::string list_name () const
      method list_count (line 442) | int list_count () const
      method empty (line 447) | bool empty () const
      method song_count (line 472) | int song_count () const
      method play_list (line 562) | play_list & play_list_map ()
      method do_ctrl_lookup (line 567) | bool do_ctrl_lookup (int ctrl)
      method ctrl_is_valid (line 572) | bool ctrl_is_valid (int ctrl)

FILE: libseq66/include/play/portslist.hpp
  type seq66 (line 43) | namespace seq66
    type portname (line 52) | enum class portname
    class portslist (line 65) | class portslist
      type status (line 77) | enum class status
      method clear (line 158) | void clear ()
      method count (line 166) | int count () const
      method empty (line 171) | bool empty () const
      method active (line 176) | bool active () const
      method is_port_map (line 181) | bool is_port_map () const
      method active (line 186) | void active (bool flag)
      method is_disabled (line 218) | bool is_disabled (bussbyte bus) const
      method container (line 225) | container & master_io ()
      method container (line 230) | const container & master_io () const
      method io (line 264) | io & io_block (const std::string & nickname)

FILE: libseq66/include/play/screenset.hpp
  type seq66 (line 56) | namespace seq66
    class playset (line 58) | class playset
      method playset (line 667) | playset (const playset &) = default;
      method playset (line 668) | playset & operator = (const playset &) = default;
      method playset (line 669) | playset (playset &&) = default;
      method playset (line 670) | playset & operator = (playset &&) = default;
      method clear (line 673) | void clear ()
      method set_count (line 683) | int set_count () const
      method seq_count (line 688) | int seq_count () const
      method array (line 695) | const array & seq_container () const
      method array (line 700) | array & seq_container ()
    class screenset (line 66) | class screenset
      method screenset (line 265) | screenset () = delete;
      method screenset (line 278) | screenset (const screenset &) = default;
      method screenset (line 279) | screenset & operator = (const screenset &) = default;
      method screenset (line 280) | screenset (screenset &&) = default;
      method screenset (line 281) | screenset & operator = (screenset &&) = default;
      method number (line 284) | static number limit ()
      method number (line 293) | static number unassigned ()
      method is_unassigned (line 298) | static bool is_unassigned (number n)
      method is_unassigned (line 303) | bool is_unassigned () const
      method dummy (line 308) | bool dummy () const
      method usable (line 313) | bool usable () const
      method set_size (line 318) | int set_size () const
      method offset (line 323) | seq::number offset () const
      method sequence_high (line 328) | int sequence_high () const
      method rows (line 333) | int rows () const
      method columns (line 338) | int columns () const
      method swap_coordinates (line 343) | bool swap_coordinates () const
      method count (line 348) | int count () const
      method set_number (line 353) | screenset::number set_number () const
      method is_playscreen (line 365) | bool is_playscreen () const
      method loop (line 384) | seq::pointer loop (seq::number seqno)
      method loop (line 389) | const seq::pointer loop (seq::number seqno) const
      method color (line 394) | int color (seq::number seqno) const
      method active (line 400) | bool active (seq::number seqno) const
      method empty (line 405) | bool empty (seq::number seqno) const
      method recording (line 410) | bool recording (seq::number seqno) const
      method is_exportable (line 418) | bool is_exportable (seq::number seqno) const
      method is_dirty_main (line 423) | bool is_dirty_main (seq::number seqno) const
      method is_dirty_edit (line 428) | bool is_dirty_edit (seq::number seqno) const
      method is_dirty_perf (line 433) | bool is_dirty_perf (seq::number seqno) const
      method is_dirty_names (line 438) | bool is_dirty_names (seq::number seqno) const
      method activate (line 443) | void activate (seq::number slotnum, seq::number seqno, bool flag = t...
      method armed (line 450) | bool armed (seq::number seqno) const
      method armed_status (line 456) | bool armed_status (seq::number seqno) const
      method muted (line 462) | bool muted (seq::number seqno) const
      method seq_in_set (line 467) | bool seq_in_set (seq::number seqno) const
      method exec_set_function (line 495) | bool exec_set_function (sethandler s, screenset::number index)
      method seq (line 552) | const seq & seqinfo (seq::number seqno) const
      method container (line 586) | const container & seq_container () const
      method container (line 591) | container & seq_container ()
      method is_playscreen (line 596) | void is_playscreen (bool flag)
      method seq (line 601) | seq & seqinfo (seq::number seqno)
      method panic (line 606) | void panic ()
    class playset (line 623) | class playset
      method playset (line 667) | playset (const playset &) = default;
      method playset (line 668) | playset & operator = (const playset &) = default;
      method playset (line 669) | playset (playset &&) = default;
      method playset (line 670) | playset & operator = (playset &&) = default;
      method clear (line 673) | void clear ()
      method set_count (line 683) | int set_count () const
      method seq_count (line 688) | int seq_count () const
      method array (line 695) | const array & seq_container () const
      method array (line 700) | array & seq_container ()

FILE: libseq66/include/play/seq.hpp
  type seq66 (line 68) | namespace seq66
    class seq (line 82) | class seq
      method seq (line 209) | seq (const seq &) = default;
      method seq (line 210) | seq & operator = (const seq &) = default;
      method seq (line 211) | seq (seq &&) = default;
      method seq (line 212) | seq & operator = (seq &&) = default;
      method maximum (line 228) | static int maximum ()
      method number (line 238) | static number metronome ()
      method number (line 253) | static number limit ()
      method number (line 262) | static number unassigned ()
      method number (line 272) | static number all ()
      method legal (line 283) | static bool legal (int seqno)
      method unassigned (line 293) | static bool unassigned (number seqno)
      method assigned (line 298) | static bool assigned (number seqno)
      method valid (line 307) | static bool valid (number seqno)
      method disabled (line 317) | static bool disabled (number seqno)
      method pointer (line 322) | const pointer loop () const
      method pointer (line 327) | pointer loop ()
      method active (line 343) | bool active () const
      method empty (line 348) | bool empty () const
      method recording (line 353) | bool recording () const
      method armed_status (line 358) | bool armed_status () const
      method queued (line 363) | bool queued () const
      method clear_snapshot (line 370) | void clear_snapshot ()
      method save_snapshot (line 375) | void save_snapshot ()
      method restore_snapshot (line 380) | void restore_snapshot ()
      method seq_number (line 386) | seq::number seq_number () const
      method change_seq_number (line 406) | void change_seq_number (seq::number seqno)
      method armed_status (line 412) | void armed_status (bool flag)
      method queued (line 417) | void queued (bool flag)

FILE: libseq66/include/play/sequence.hpp
  type seq66 (line 61) | namespace seq66
    class mastermidibus (line 64) | class mastermidibus
    class notemapper (line 65) | class notemapper
    class performer (line 66) | class performer
    type fixparameters (line 168) | struct fixparameters
    type lfoparameters (line 231) | struct lfoparameters
    class sequence (line 248) | class sequence
      type playback (line 260) | enum class playback
      type draw (line 274) | enum class draw
      type editmode (line 293) | enum class editmode
      class note_info (line 310) | class note_info
        method note_info (line 325) | note_info () :
        method midipulse (line 336) | midipulse start () const
        method midipulse (line 341) | midipulse finish () const
        method midipulse (line 346) | midipulse length () const
        method note (line 351) | int note () const
        method valid (line 356) | bool valid () const
        method velocity (line 361) | int velocity () const
        method selected (line 366) | bool selected () const
        method non_note (line 371) | bool non_note ()
      method maximum (line 1051) | static short maximum ()
      method recorder (line 1056) | static short recorder ()
      method is_recorder (line 1061) | static short is_recorder (int s)
      method metronome (line 1066) | static short metronome ()
      method is_metronome (line 1071) | static bool is_metronome (int s)
      method limit (line 1076) | static int limit ()
      method is_normal (line 1081) | static bool is_normal (int s)
      method unassigned (line 1086) | static int unassigned ()
      method eventlist (line 1091) | eventlist & events ()
      method eventlist (line 1096) | const eventlist & events () const
      method empty (line 1101) | bool empty () const
      method any_selected_notes (line 1106) | bool any_selected_notes () const
      method any_selected_events (line 1111) | bool any_selected_events () const
      method any_selected_events (line 1116) | bool any_selected_events (midibyte status, midibyte cc) const
      method is_exportable (line 1121) | bool is_exportable () const
      method trigger_listing (line 1136) | std::string trigger_listing () const
      method trigger_count (line 1145) | int trigger_count () const
      method triggers_datasize (line 1150) | int triggers_datasize (midilong seqspec) const
      method any_trigger_transposed (line 1155) | int any_trigger_transposed () const
      method selected_trigger_count (line 1165) | int selected_trigger_count () const
      method set_trigger_paste_tick (line 1170) | void set_trigger_paste_tick (midipulse tick)
      method midipulse (line 1175) | midipulse get_trigger_paste_tick () const
      method time_signature_count (line 1182) | int time_signature_count () const
      method is_recorder_seq (line 1192) | bool is_recorder_seq () const
      method is_metro_seq (line 1197) | bool is_metro_seq () const
      method is_normal_seq (line 1208) | bool is_normal_seq () const
      method seq_number (line 1213) | int seq_number () const
      method seq_number_string (line 1218) | std::string seq_number_string () const
      method seq_number (line 1223) | void seq_number (int seqno)
      method color (line 1229) | int color () const
      method editmode (line 1237) | editmode edit_mode () const
      method midibyte (line 1242) | midibyte edit_mode_byte () const
      method edit_mode (line 1247) | void edit_mode (editmode mode)
      method edit_mode (line 1252) | void edit_mode (midibyte b)
      method unmodify (line 1260) | void unmodify ()
      method have_undo (line 1272) | bool have_undo () const
      method set_have_redo (line 1281) | void set_have_redo ()
      method have_redo (line 1286) | bool have_redo () const
      method measures (line 1303) | int measures () const
      method event_threshold (line 1308) | bool event_threshold () const
      method get_ppqn (line 1313) | int get_ppqn () const
      method get_beats_per_bar (line 1320) | int get_beats_per_bar () const
      method get_beat_width (line 1327) | int get_beat_width () const
      method timesig_beats_per_measure (line 1332) | int timesig_beats_per_measure () const
      method timesig_beat_width (line 1337) | int timesig_beat_width () const
      method midipulse (line 1349) | midipulse measures_to_ticks (int measures = 1) const
      method clocks_per_metronome (line 1358) | void clocks_per_metronome (int cpm)
      method clocks_per_metronome (line 1363) | int clocks_per_metronome () const
      method set_32nds_per_quarter (line 1368) | void set_32nds_per_quarter (int tpq)
      method get_32nds_per_quarter (line 1373) | int get_32nds_per_quarter () const
      method us_per_quarter_note (line 1378) | void us_per_quarter_note (long upqn)
      method us_per_quarter_note (line 1383) | long us_per_quarter_note () const
      method get_song_mute (line 1392) | bool get_song_mute () const
      method transposable (line 1400) | bool transposable () const
      method is_default_name (line 1416) | bool is_default_name () const
      method is_new_pattern (line 1421) | bool is_new_pattern () const
      method seq_in_edit (line 1434) | void seq_in_edit (bool edit)
      method seq_in_edit (line 1439) | bool seq_in_edit () const
      method apply_length (line 1460) | bool apply_length (int meas = 0, bool user_change = false)
      method midipulse (line 1468) | midipulse get_length () const
      method midipulse (line 1473) | midipulse get_length_plus () const
      method midipulse (line 1486) | midipulse last_tick () const
      method midipulse (line 1498) | midipulse mod_last_tick ()
      method armed (line 1509) | bool armed () const
      method muted (line 1514) | bool muted () const
      method set_popup (line 1524) | void set_popup (bool flag)
      method has_popup (line 1529) | bool has_popup () const
      method get_queued (line 1534) | bool get_queued () const
      method midipulse (line 1539) | midipulse get_queued_tick () const
      method check_queued_tick (line 1544) | bool check_queued_tick (midipulse tick) const
      method recording (line 1559) | bool recording () const
      method alter_recording (line 1564) | bool alter_recording () const
      method alteration (line 1569) | alteration record_alteration () const
      method record_alteration (line 1574) | void record_alteration (alteration a)
      method quantized_recording (line 1579) | bool quantized_recording () const
      method quantizing (line 1584) | bool quantizing () const
      method tightened_recording (line 1589) | bool tightened_recording () const
      method tightening (line 1594) | bool tightening () const
      method notemapped_recording (line 1599) | bool notemapped_recording () const
      method notemapping (line 1604) | bool notemapping () const
      method expanded_recording (line 1609) | bool expanded_recording () const
      method expanding (line 1614) | bool expanding () const
      method oneshot_recording (line 1619) | bool oneshot_recording () const
      method overwriting (line 1626) | bool overwriting () const
      method thru (line 1631) | bool thru () const
      method midipulse (line 1636) | midipulse snap () const
      method midipulse (line 1641) | midipulse step_edit_note_length () const    /* auto-step/step-edit  ...
      method one_shot (line 1652) | bool one_shot () const
      method midipulse (line 1657) | midipulse one_shot_tick () const
      method check_one_shot_tick (line 1662) | bool check_one_shot_tick (midipulse tick) const
      method loop_count_max (line 1667) | int loop_count_max () const
      method song_recording (line 1672) | bool song_recording () const
      method off_from_snap (line 1677) | bool off_from_snap () const
      method snap_it (line 1682) | bool snap_it () const
      method song_playback_block (line 1687) | bool song_playback_block () const
      method song_recording_snap (line 1692) | bool song_recording_snap () const
      method midipulse (line 1697) | midipulse song_record_tick () const
      method modified (line 1705) | bool modified () const
      method midibyte (line 1719) | midibyte seq_midi_channel () const
      method midibyte (line 1724) | midibyte midi_channel (const event & ev) const
      method midibyte (line 1729) | midibyte midi_channel () const
      method free_channel (line 1734) | bool free_channel () const
      method is_smf_0 (line 1743) | bool is_smf_0 () const
      method midipulse (line 1882) | midipulse get_trigger_offset () const
      method bussbyte (line 1887) | bussbyte seq_midi_bus () const
      method bussbyte (line 1892) | bussbyte true_bus () const
      method bussbyte (line 1897) | bussbyte seq_midi_in_bus () const
      method bussbyte (line 1902) | bussbyte true_in_bus () const
      method has_in_bus (line 1907) | bool has_in_bus () const
      method select_all_notes (line 1949) | void select_all_notes (bool inverse = false)
      method zero_markers (line 2023) | void zero_markers ()
      method cbegin (line 2038) | event::buffer::const_iterator cbegin () const
      method cend (line 2043) | bool cend (event::buffer::const_iterator & evi) const
      method midibyte (line 2086) | midibyte musical_key () const
      method midibyte (line 2091) | midibyte musical_scale () const
      method midibyte (line 2096) | midibyte musical_chord () const
      method background_sequence (line 2101) | int background_sequence () const
      method channel_match (line 2122) | bool channel_match () const
      method loop_reset (line 2129) | bool loop_reset () const
      method clear_clipboard (line 2140) | static void clear_clipboard ()
      method is_draw_note (line 2151) | static bool is_draw_note (draw dt)
      method is_draw_note_onoff (line 2161) | static bool is_draw_note_onoff (draw dt)
      method armed (line 2185) | void armed (bool flag)
      method free_channel (line 2190) | void free_channel (bool flag)
      method mastermidibus (line 2204) | mastermidibus * master_bus ()
      method performer (line 2209) | const performer * perf () const
      method performer (line 2214) | performer * perf ()
      method channels_match (line 2257) | bool channels_match (const event & e) const
      method draw_locked (line 2263) | void draw_locked (bool flag)
      method one_shot (line 2268) | void one_shot (bool f)
      method off_from_snap (line 2273) | void off_from_snap (bool f)
      method song_playback_block (line 2278) | void song_playback_block (bool f)
      method song_recording (line 2283) | void song_recording (bool f)
      method song_recording_snap (line 2288) | void song_recording_snap (bool f)
      method song_record_tick (line 2293) | void song_record_tick (midipulse t)
      method channel_match (line 2298) | void channel_match (bool flag)

FILE: libseq66/include/play/setmapper.hpp
  type seq66 (line 53) | namespace seq66
    class setmapper (line 61) | class setmapper
      method setmapper (line 174) | setmapper () = delete;
      method setmapper (line 193) | setmapper (const setmapper &) = delete;
      method setmapper (line 194) | setmapper & operator = (const setmapper &) = delete;
      method setmapper (line 195) | setmapper (setmapper &&) = delete;
      method setmapper (line 196) | setmapper & operator = (setmapper &&) = delete;
      method seq_set (line 216) | screenset::number seq_set (seq::number seqno) const
      method sequences_in_sets (line 228) | int sequences_in_sets () const
      method seq_to_offset (line 241) | int seq_to_offset (seq::cref s) const
      method grid_to_index (line 246) | seq::number grid_to_index (int row, int column) const
      method grid_to_seq (line 251) | seq::number grid_to_seq (int row, int column) const
      method grid_to_seq (line 256) | seq::number grid_to_seq
      method seq_to_grid (line 265) | bool seq_to_grid
      method index_to_grid (line 275) | bool index_to_grid (seq::number seqno, int & row, int & column) const
      method max_slot_shift (line 280) | int max_slot_shift () const
      method slot_shift_delta (line 285) | int slot_shift_delta () const
      method clear (line 290) | void clear ()
      method sequence_count (line 297) | int sequence_count () const
      method rows (line 302) | int rows () const
      method columns (line 307) | int columns () const
      method group_event (line 312) | bool group_event () const
      method group_error (line 317) | bool group_error () const
      method group_mode (line 330) | bool group_mode () const
      method group_mode (line 335) | void group_mode (bool flag)
      method toggle_group_mode (line 340) | void toggle_group_mode ()
      method any_in_edit (line 345) | bool any_in_edit () const
      method reset_sequences (line 354) | void reset_sequences (bool pause, sequence::playback mode)
      method sequence_high (line 366) | seq::number sequence_high () const
      method sequence_max (line 371) | seq::number sequence_max () const
      method set_edit_sequence (line 385) | void set_edit_sequence (seq::number seqno)
      method unset_edit_sequence (line 399) | void unset_edit_sequence (seq::number seqno)
      method is_edit_sequence (line 417) | bool is_edit_sequence (seq::number seqno) const
      method is_exportable (line 432) | bool is_exportable (seq::number seqno) const
      method is_dirty_main (line 437) | bool is_dirty_main (seq::number seqno) const
      method is_dirty_edit (line 442) | bool is_dirty_edit (seq::number seqno) const
      method is_dirty_perf (line 447) | bool is_dirty_perf (seq::number seqno) const
      method is_dirty_names (line 452) | bool is_dirty_names (seq::number seqno) const
      method color (line 457) | int color (seq::number seqno) const
      method color (line 462) | bool color (seq::number seqno, int c)
      method is_seq_active (line 467) | bool is_seq_active (seq::number seqno) const
      method is_seq_empty (line 472) | bool is_seq_empty (seq::number seqno) const
      method is_seq_recording (line 477) | bool is_seq_recording (seq::number seqno) const
      method first_seq (line 482) | seq::number first_seq () const
      method activate (line 491) | void activate (int seqno, seq::number seqnum, bool flag = true)
      method song_recording_start (line 506) | void song_recording_start (midipulse tick, bool snap = true)
      method song_recording_stop (line 511) | void song_recording_stop (midipulse tick)
      method clear_snapshot (line 520) | void clear_snapshot ()
      method save_snapshot (line 533) | void save_snapshot ()
      method restore_snapshot (line 545) | void restore_snapshot ()
      method needs_update (line 555) | bool needs_update () const
      method exec_set_function (line 573) | bool exec_set_function (screenset::sethandler s)
      method exec_set_function (line 578) | bool exec_set_function (screenset::sethandler s, screenset::slothand...
      method exec_set_function (line 583) | bool exec_set_function (screenset::slothandler p)
      method exec_slot_function (line 588) | bool exec_slot_function
      method set_last_ticks (line 597) | void set_last_ticks (midipulse tick)
      method push_trigger_undo (line 625) | void push_trigger_undo ()
      method pop_trigger_undo (line 631) | void pop_trigger_undo ()
      method pop_trigger_redo (line 637) | void pop_trigger_redo ()
      method loop (line 670) | const seq::pointer loop (seq::number seqno) const
      method loop (line 686) | seq::pointer loop (seq::number seqno)
      method play_seq (line 698) | seq::number play_seq (seq::number seqno)
      method save_queued (line 703) | void save_queued (int hotseq)
      method unqueue (line 708) | void unqueue (int hotseq)
      method armed (line 715) | bool armed (seq::number seqno) const
      method armed (line 720) | void armed (seq::number seqno, bool flag)
      method muted (line 725) | bool muted (seq::number seqno) const
      method arm (line 730) | void arm (seq::number seqno)
      method mute (line 735) | void mute (seq::number seqno)
      method arm (line 744) | void arm ()
      method mute (line 750) | void mute ()
      method mute_all_tracks (line 756) | void mute_all_tracks (bool flag)
      method apply_armed_statuses (line 764) | void apply_armed_statuses ()
      method all_notes_off (line 772) | void all_notes_off ()
      method panic (line 778) | void panic ()
      method screenset (line 800) | screenset * play_screen ()
      method screenset (line 805) | const screenset * play_screen () const
      method change_playscreen (line 810) | screenset::number change_playscreen (int amount)
      method playscreen_number (line 816) | screenset::number playscreen_number () const
      method playscreen_offset (line 821) | seq::number playscreen_offset () const
      method playscreen_active_count (line 826) | int playscreen_active_count () const
      method increment_screenset (line 841) | screenset::number increment_screenset (int amount)
      method decrement_screenset (line 846) | screenset::number decrement_screenset (int amount)
      method name (line 859) | bool name (const std::string & nm)
      method is_screenset_active (line 864) | bool is_screenset_active (screenset::number setno) const
      method is_screenset_available (line 869) | bool is_screenset_available (screenset::number setno) const
      method seq_in_playscreen (line 896) | bool seq_in_playscreen (seq::number seqno)
      method screenset_size (line 901) | int screenset_size () const
      method swap_sets (line 910) | bool swap_sets (seq::number set0, seq::number set1)
      method set_mutes (line 915) | bool set_mutes (mutegroup::number gmute, const midibooleans & bits)
      method add_set (line 944) | setmaster::container::iterator add_set (screenset::number setno)
      method find_by_value (line 949) | setmaster::container::iterator find_by_value (screenset::number setno)
      method remove_set (line 954) | bool remove_set (screenset::number setno)
      method clear_set (line 959) | bool clear_set (screenset::number setno)
      method clamp_group (line 964) | mutegroup::number clamp_group (mutegroup::number group) const
      method check_group (line 969) | bool check_group (mutegroup::number group) const
      method clamp (line 974) | screenset::number clamp (screenset::number offset) const
      method screenset (line 979) | screenset & dummy_screenset ()
      method screenset (line 984) | const screenset & dummy_screenset () const
      method mutegroups (line 989) | mutegroups & mutes ()
      method mutegroups (line 994) | const mutegroups & mutes () const
      method setmaster (line 999) | setmaster & master ()
      method setmaster (line 1004) | const setmaster & master () const

FILE: libseq66/include/play/setmaster.hpp
  type seq66 (line 52) | namespace seq66
    class setmaster (line 60) | class setmaster
      method setmaster (line 158) | setmaster (const setmaster &) = default;
      method setmaster (line 159) | setmaster & operator = (const setmaster &) = default;
      method setmaster (line 160) | setmaster (setmaster &&) = default;
      method setmaster (line 161) | setmaster & operator = (setmaster &&) = default;
      method Rows (line 164) | static int Rows ()
      method Columns (line 169) | static int Columns ()
      method Size (line 174) | static int Size ()
      method swap_coordinates (line 179) | bool swap_coordinates () const
      method name (line 188) | bool name (screenset::number setno, const std::string & nm)
      method is_screenset_active (line 194) | bool is_screenset_active (screenset::number setno) const
      method is_screenset_available (line 200) | bool is_screenset_available (screenset::number setno) const
      method is_screenset_valid (line 205) | bool is_screenset_valid (screenset::number setno) const
      method screenset_count (line 210) | int screenset_count () const
      method highest_set (line 217) | int highest_set () const
      method screenset_max (line 222) | int screenset_max () const
      method inside_set (line 236) | bool inside_set (int row, int column) const
      method clear (line 242) | void clear ()
      method rows (line 247) | int rows () const
      method columns (line 252) | int columns () const
      method clamp (line 282) | screenset::number clamp (screenset::number offset) const
      method screenset (line 295) | screenset & dummy_screenset ()
      method screenset (line 300) | const screenset & dummy_screenset () const
      method container (line 305) | container & set_container ()        /* for setmapper and performer  */
      method container (line 310) | const container & set_container () const

FILE: libseq66/include/play/songsummary.hpp
  type seq66 (line 39) | namespace seq66
    class performer (line 41) | class performer
    class songsummary (line 47) | class songsummary

FILE: libseq66/include/play/triggers.hpp
  type seq66 (line 44) | namespace seq66
    class sequence (line 46) | class sequence
    class triggers (line 47) | class triggers
      type grow (line 333) | enum class grow
      method triggers (line 435) | triggers (const triggers & rhs) = default;
      method set_ppqn (line 446) | void set_ppqn (int ppqn)
      method set_length (line 460) | void set_length (int len)
      method container (line 466) | const container & triggerlist () const
      method container (line 471) | container & triggerlist ()
      method count (line 476) | int count () const
      method number_selected (line 484) | int number_selected () const
      method clear (line 545) | void clear ()
      method reset_draw_trigger_marker (line 557) | void reset_draw_trigger_marker ()
      method set_trigger_paste_tick (line 562) | void set_trigger_paste_tick (midipulse tick)
      method midipulse (line 567) | midipulse get_trigger_paste_tick () const
      method cend (line 582) | bool cend (container::iterator & evi) const // no can do const_iterator
    class trigger (line 62) | class trigger
      type splitpoint (line 73) | enum class splitpoint
      method trigger (line 126) | trigger (const trigger &) = default;
      method trigger (line 127) | trigger & operator = (const trigger &) = default;
      method is_valid (line 147) | bool is_valid () const
      method midipulse (line 159) | midipulse length () const
      method midipulse (line 164) | midipulse tick_start () const
      method tick_start (line 169) | void tick_start (midipulse s)
      method increment_tick_start (line 174) | void increment_tick_start (midipulse s)
      method decrement_tick_start (line 179) | void decrement_tick_start (midipulse s)
      method at_trigger_transition (line 197) | bool at_trigger_transition (midipulse s, midipulse e)
      method covers (line 206) | bool covers (midipulse tick)
      method midipulse (line 211) | midipulse tick_end () const
      method tick_end (line 216) | void tick_end (midipulse e)
      method increment_tick_end (line 221) | void increment_tick_end (midipulse s)
      method decrement_tick_end (line 226) | void decrement_tick_end (midipulse s)
      method midipulse (line 231) | midipulse offset () const
      method offset (line 236) | void offset (midipulse o)
      method increment_offset (line 241) | void increment_offset (midipulse s)
      method decrement_offset (line 246) | void decrement_offset (midipulse s)
      method midibyte (line 259) | midibyte transpose_byte () const
      method transpose_byte (line 264) | void transpose_byte (midibyte t)                /* when reading a fi...
      method transpose (line 272) | int transpose () const
      method transposed (line 277) | bool transposed () const
      method transpose (line 284) | void transpose (int t)                          /* to modify a trigg...
      method selected (line 290) | bool selected () const
      method selected (line 295) | void selected (bool s)
      method midipulse (line 304) | midipulse trigger_marker (midipulse len)
    class triggers (line 320) | class triggers
      type grow (line 333) | enum class grow
      method triggers (line 435) | triggers (const triggers & rhs) = default;
      method set_ppqn (line 446) | void set_ppqn (int ppqn)
      method set_length (line 460) | void set_length (int len)
      method container (line 466) | const container & triggerlist () const
      method container (line 471) | container & triggerlist ()
      method count (line 476) | int count () const
      method number_selected (line 484) | int number_selected () const
      method clear (line 545) | void clear ()
      method reset_draw_trigger_marker (line 557) | void reset_draw_trigger_marker ()
      method set_trigger_paste_tick (line 562) | void set_trigger_paste_tick (midipulse tick)
      method midipulse (line 567) | midipulse get_trigger_paste_tick () const
      method cend (line 582) | bool cend (container::iterator & evi) const // no can do const_iterator

FILE: libseq66/include/seq66_features.hpp
  type seq66 (line 53) | namespace seq66
    type toggler (line 61) | enum class toggler
    type msglevel (line 82) | enum class msglevel

FILE: libseq66/include/sessions/clinsmanager.hpp
  type seq66 (line 63) | namespace seq66
    class clinsmanager (line 72) | class clinsmanager : public smanager
      method clinsmanager (line 105) | clinsmanager (const clinsmanager &) = delete;
      method clinsmanager (line 106) | clinsmanager & operator = (const clinsmanager &) = delete;
      method nsmclient (line 110) | nsmclient * nsm_client ()
      method nsm_active (line 116) | bool nsm_active () const
      method nsm_active (line 121) | void nsm_active (bool flag)

FILE: libseq66/include/sessions/smanager.hpp
  type seq66 (line 44) | namespace seq66
    class smanager (line 51) | class smanager
      method smanager (line 133) | smanager (const smanager &) = delete;
      method smanager (line 134) | smanager & operator = (const smanager &) = delete;
      method error_active (line 148) | bool error_active () const
      method last_dirty_status (line 168) | bool last_dirty_status () const
      method is_help (line 173) | bool is_help () const
      method internal_error_pending (line 181) | bool internal_error_pending () const
      method session_manager_name (line 238) | virtual void session_manager_name (const std::string & mgrname)
      method session_manager_path (line 243) | virtual void session_manager_path (const std::string & pathname)
      method session_display_name (line 248) | virtual void session_display_name (const std::string & dispname)
      method session_client_id (line 253) | virtual void session_client_id (const std::string & clid)
      method performer (line 280) | const performer * perf () const
      method performer (line 285) | performer * perf ()
      method midi_filename (line 290) | void midi_filename (const std::string & fname)
      method last_dirty_status (line 295) | void last_dirty_status (bool flag)
      method is_help (line 300) | void is_help (bool flag)

FILE: libseq66/include/util/automutex.hpp
  type seq66 (line 44) | namespace seq66
    class automutex (line 72) | class automutex
      method automutex (line 85) | automutex () = delete;
      method automutex (line 86) | automutex (const automutex &) = delete;
      method automutex (line 87) | automutex & operator = (const automutex &) = delete;
      method automutex (line 99) | automutex (recmutex & my_mutex) : m_safety_mutex (my_mutex)
      method lock (line 118) | void lock ()
      method unlock (line 123) | void unlock ()

FILE: libseq66/include/util/basic_macros.h
  type cbool_t (line 126) | typedef int cbool_t;

FILE: libseq66/include/util/basic_macros.hpp
  type seq66 (line 51) | namespace seq66

FILE: libseq66/include/util/condition.hpp
  type seq66 (line 45) | namespace seq66
    class condition (line 55) | class condition
      class impl (line 65) | class impl
      method condition (line 95) | condition (condition &&) = delete;
      method condition (line 97) | condition & operator = (condition &&) = delete;
      method lock (line 101) | void lock () const
      method unlock (line 106) | void unlock () const
      method recmutex (line 111) | recmutex & locker ()
    class synchronizer (line 128) | class synchronizer
      method synchronizer (line 149) | synchronizer (const synchronizer &) = delete;
      method synchronizer (line 150) | synchronizer & operator = (synchronizer &&) = delete;
      method synchronizer (line 151) | synchronizer & operator = (const synchronizer &) = delete;

FILE: libseq66/include/util/filefunctions.hpp
  type seq66 (line 46) | namespace seq66
    function get_wildcards (line 219) | inline bool get_wildcards

FILE: libseq66/include/util/named_bools.hpp
  type seq66 (line 40) | namespace seq66
    class named_bools (line 48) | class named_bools
      method named_bools (line 62) | named_bools () : m_container ()
      method add (line 67) | bool add (const std::string & name, bool value)
      method get (line 74) | bool get (const std::string & name) const
      method set (line 80) | void set (const std::string & name, bool value = true)
      method clear (line 89) | void clear ()
      method count (line 94) | int count ()

FILE: libseq66/include/util/palette.hpp
  type seq66 (line 42) | namespace seq66
    type PaletteColor (line 59) | enum class PaletteColor
    type InvertibleColor (line 104) | enum class InvertibleColor
    function palette_to_int (line 146) | inline int
    function inv_palette_to_int (line 152) | inline int
    class palette (line 166) | class palette
      method no_color (line 217) | bool no_color (PaletteColor index) const
      method clear (line 222) | void clear ()
      method count (line 227) | int count ()
      method container (line 234) | const container & entries () const
      method container (line 239) | container & entries ()
    function COLOR (line 307) | const COLOR &
    function COLOR (line 369) | const COLOR &

FILE: libseq66/include/util/recmutex.hpp
  type seq66 (line 73) | namespace seq66
    class recmutex (line 83) | class recmutex
      method recmutex (line 128) | recmutex (recmutex &&) = delete;
      method recmutex (line 130) | recmutex & operator = (recmutex &&) = delete;
      method native (line 141) | native & native_locker () const

FILE: libseq66/include/util/rect.hpp
  type seq66 (line 37) | namespace seq66
    class rect (line 50) | class rect
      method clear (line 70) | void clear ()
      method is_empty (line 75) | bool is_empty () const
      method xy_to_rect (line 87) | void xy_to_rect (int x0, int y0, int x1, int y1)
      method x (line 92) | int x () const
      method x (line 97) | void x (int v)
      method x0 (line 102) | int x0 () const
      method x0 (line 107) | void x0 (int v)
      method x_incr (line 117) | void x_incr (int v)
      method y (line 122) | int y () const
      method y (line 127) | void y (int v)
      method y0 (line 132) | int y0 () const
      method y0 (line 137) | void y0 (int v)
      method y_incr (line 147) | void y_incr (int v)
      method width (line 152) | int width () const
      method width (line 157) | void width (int w)
      method x1 (line 162) | int x1 () const
      method x1 (line 167) | void x1 (int x)
      method width_incr (line 172) | void width_incr (int w)
      method height (line 177) | int height () const
      method height (line 182) | void height (int h)
      method y1 (line 187) | int y1 () const
      method y1 (line 192) | void y1 (int h)
      method height_incr (line 197) | void height_incr (int h)
      method xy_incr (line 202) | void xy_incr (int xv, int yv)
      method calculated_width (line 215) | static int calculated_width (int x1, int x2)
      method calculated_height (line 225) | static int calculated_height (int y1, int y2)

FILE: libseq66/include/util/ring_buffer.hpp
  type seq66 (line 47) | namespace seq66
    class ring_buffer (line 51) | class ring_buffer
      method reset (line 86) | void reset ()
      method clear (line 91) | void clear ()
      method buffer_size (line 98) | int buffer_size () const
      method count (line 103) | int count () const
      method count_max (line 108) | int count_max () const
      method empty (line 113) | bool empty () const
      method dropped (line 118) | int dropped () const
      method pop_front (line 131) | void pop_front ()
      method reference (line 145) | reference front ()
      method const_reference (line 150) | const_reference front () const
      method reference (line 160) | reference back ()
      method const_reference (line 165) | const_reference back () const
      method previous_tail (line 176) | size_t previous_tail ()

FILE: libseq66/include/util/strfunctions.hpp
  type seq66 (line 52) | namespace seq66
    function not_npos (line 70) | inline bool
    function is_npos (line 76) | inline bool
    function string_format (line 234) | std::string string_format (const std::string & format, Args ... args)

FILE: libseq66/src/cfg/basesettings.cpp
  type seq66 (line 43) | namespace seq66

FILE: libseq66/src/cfg/cmdlineopts.cpp
  type option (line 105) | struct option
  function s_help_2 (line 302) | static const std::string s_help_2

FILE: libseq66/src/cfg/comments.cpp
  type seq66 (line 35) | namespace seq66

FILE: libseq66/src/cfg/configfile.cpp
  type seq66 (line 58) | namespace seq66
    function delete_configuration (line 988) | bool
    function copy_configuration (line 1008) | bool
    function get_current_date_time (line 1046) | std::string

FILE: libseq66/src/cfg/midicontrolfile.cpp
  type seq66 (line 44) | namespace seq66
    function read_midi_control_file (line 1206) | bool
    function bussbyte (line 1380) | bussbyte
    function write_midi_control_file (line 1586) | bool

FILE: libseq66/src/cfg/mutegroupsfile.cpp
  type seq66 (line 42) | namespace seq66
    function mutegroups (line 51) | static mutegroups &
    function open_mutegroups (line 491) | bool
    function save_mutegroups (line 503) | bool

FILE: libseq66/src/cfg/notemapfile.cpp
  type seq66 (line 39) | namespace seq66
    function copy_notemapper (line 351) | bool

FILE: libseq66/src/cfg/patchesfile.cpp
  type seq66 (line 39) | namespace seq66
    function open_patches (line 288) | bool
    function save_patches (line 314) | bool
    function save_patches (line 348) | bool
    function copy_patches (line 396) | bool

FILE: libseq66/src/cfg/playlistfile.cpp
  type seq66 (line 54) | namespace seq66
    function open_playlist (line 587) | bool
    function save_playlist (line 637) | bool
    function save_playlist (line 677) | bool
    function copy_playlist_songs (line 733) | bool

FILE: libseq66/src/cfg/rcfile.cpp
  type seq66 (line 81) | namespace seq66
    function write_rc_file (line 1294) | bool
    function delete_configuration (line 1310) | bool
    function copy_configuration (line 1343) | bool

FILE: libseq66/src/cfg/rcsettings.cpp
  type seq66 (line 49) | namespace seq66

FILE: libseq66/src/cfg/recent.cpp
  type seq66 (line 40) | namespace seq66
    function recent (line 67) | recent &

FILE: libseq66/src/cfg/scales.cpp
  type seq66 (line 74) | namespace seq66
    function scales_policy (line 197) | bool
    function scales_policy (line 218) | bool
    function rotate_scale_right (line 255) | static void
    function rotate_transpose_right (line 266) | static void
    function musical_note_name (line 537) | std::string
    function musical_key_name (line 561) | std::string
    function musical_scale_name (line 571) | std::string
    function harmonic_number_valid (line 632) | bool
    function chord_number_valid (line 667) | bool
    function chord_notes (line 704) | const chord_notes &
    function chord_intervals (line 756) | std::string
    function note_in_chord (line 794) | bool
    function midi_note_frequency (line 840) | double
    function analyze_note (line 875) | static bool

FILE: libseq66/src/cfg/sessionfile.cpp
  type seq66 (line 48) | namespace seq66

FILE: libseq66/src/cfg/settings.cpp
  type seq66 (line 52) | namespace seq66
    function tokenization (line 182) | const tokenization &
    function tokenization (line 197) | const tokenization &
    function tokenization (line 214) | const tokenization &
    function tokenization (line 230) | const tokenization &
    function tokenization (line 248) | const tokenization &
    function tokenization (line 265) | const tokenization &
    function zoom_item (line 275) | int
    function tokenization (line 297) | const tokenization &
    function expanded_zoom_item (line 307) | int
    function tokenization (line 328) | const tokenization &
    function tokenization (line 342) | const tokenization &
    function rcsettings (line 362) | rcsettings &
    function usrsettings (line 379) | usrsettings &
    function set_configuration_defaults (line 390) | void
    function tokenization (line 404) | const tokenization &
    function tokenization (line 422) | const tokenization &
    function choose_ppqn (line 456) | int
    function ppqn_in_range (line 474) | bool
    function open_user_manual (line 486) | bool
    function open_tutorial (line 520) | bool
    function tokenization (line 551) | const tokenization &
    function tokenization (line 596) | const tokenization &
    function tokenization (line 642) | const tokenization &
    function open_share_doc_file (line 689) | std::string

FILE: libseq66/src/cfg/userinstrument.cpp
  type seq66 (line 37) | namespace seq66
    function userinstrument (line 82) | userinstrument &

FILE: libseq66/src/cfg/usermidibus.cpp
  type seq66 (line 39) | namespace seq66
    function usermidibus (line 91) | usermidibus &

FILE: libseq66/src/cfg/usrfile.cpp
  type seq66 (line 44) | namespace seq66
    function make_section_name (line 100) | static std::string

FILE: libseq66/src/cfg/usrsettings.cpp
  type seq66 (line 114) | namespace seq66
    function alteration (line 669) | alteration
    function alteration (line 694) | alteration
    function recordstyle (line 734) | recordstyle
    function recordstyle (line 750) | recordstyle
    function usermidibus (line 961) | usermidibus &
    function userinstrument (line 1005) | userinstrument &
    function midipulse (line 1286) | midipulse
    function midibpm (line 1392) | midibpm
    function midilong (line 1398) | midilong
    function midibpm (line 1404) | midibpm
    function default_color_check (line 1725) | static bool

FILE: libseq66/src/cfg/zoomer.cpp
  type seq66 (line 78) | namespace seq66
    function midipulse (line 219) | midipulse
    function adapted_seq_zoom (line 296) | int
    function adapted_perf_zoom (line 314) | int

FILE: libseq66/src/ctrl/automation.cpp
  type seq66 (line 126) | namespace seq66
    type automation (line 129) | namespace automation
      function category_to_string (line 132) | std::string
      function category (line 154) | category
      function action_to_string (line 169) | std::string
      function action (line 191) | action
      function actionable (line 213) | bool
      function ctrlstatus_to_string (line 223) | std::string
      function slot_to_string (line 403) | std::string
      function slot (line 415) | slot

FILE: libseq66/src/ctrl/keycontainer.cpp
  type seq66 (line 39) | namespace seq66
    function keycontrol (line 240) | const keycontrol &
    function keystroke (line 333) | keystroke

FILE: libseq66/src/ctrl/keycontrol.cpp
  type seq66 (line 38) | namespace seq66

FILE: libseq66/src/ctrl/keymap.cpp
  type seq66 (line 37) | namespace seq66
    function modifier_names (line 40) | std::string
    function modifier_code (line 71) | unsigned
    function ctrlkey (line 99) | ctrlkey
    function ctrlkey (line 105) | ctrlkey
    function ctrlkey (line 111) | ctrlkey
    function ctrlkey (line 117) | ctrlkey
    function ctrlkey (line 123) | ctrlkey
    type qt_keycodes (line 141) | struct qt_keycodes
    function qt_keycodes (line 256) | static qt_keycodes &
    function setup_qt_azerty_fr_keys (line 619) | static void
    function is_undefined_qt_key (line 714) | bool
    function ctrlkey (line 725) | ctrlkey
    function is_invalid_ordinal (line 735) | bool
    function qt_keycode_map (line 765) | static qt_keycode_map &
    function qt_keyname_map (line 785) | static qt_keyname_map &
    function keymap_size (line 796) | int
    function initialize_key_maps (line 807) | static bool
    function ordinal_to_qt_key (line 897) | unsigned
    function ctrlkey (line 947) | ctrlkey
    function qt_modkey_name (line 1021) | std::string
    function ctrlkey (line 1041) | ctrlkey
    function qt_ordinal_keyname (line 1063) | std::string
    function modify_keyboard_layout (line 1075) | void

FILE: libseq66/src/ctrl/keystroke.cpp
  type seq66 (line 39) | namespace seq66
    type charpair_t (line 91) | struct charpair_t
    type charpair_t (line 101) | struct charpair_t
    function ctrlkey (line 146) | ctrlkey
    function ctrlkey (line 186) | ctrlkey
    function ctrlkey (line 208) | ctrlkey

FILE: libseq66/src/ctrl/midicontrol.cpp
  type seq66 (line 50) | namespace seq66

FILE: libseq66/src/ctrl/midicontrolbase.cpp
  type seq66 (line 39) | namespace seq66

FILE: libseq66/src/ctrl/midicontrolin.cpp
  type seq66 (line 80) | namespace seq66
    function midicontrol (line 183) | const midicontrol &

FILE: libseq66/src/ctrl/midicontrolout.cpp
  type seq66 (line 76) | namespace seq66
    function auto_name (line 190) | std::string
    function seqaction_to_string (line 200) | std::string
    function action_to_string (line 217) | std::string
    function event (line 429) | event

FILE: libseq66/src/ctrl/midimacro.cpp
  type seq66 (line 51) | namespace seq66
    function midibytes (line 66) | const midibytes &

FILE: libseq66/src/ctrl/midimacros.cpp
  type seq66 (line 51) | namespace seq66
    function midibytes (line 131) | midibytes
    function midibytes (line 181) | midibytes
    function midimacro (line 195) | const midimacro &
    function tokenization (line 215) | tokenization

FILE: libseq66/src/ctrl/midioperation.cpp
  type seq66 (line 37) | namespace seq66

FILE: libseq66/src/ctrl/opcontainer.cpp
  type seq66 (line 38) | namespace seq66
    function midioperation (line 101) | const midioperation &

FILE: libseq66/src/ctrl/opcontrol.cpp
  type seq66 (line 36) | namespace seq66

FILE: libseq66/src/ctrl/winkeys.hpp
  function qt_keycodes (line 47) | static qt_keycodes &
  function setup_qt_azerty_fr_keys (line 383) | static void

FILE: libseq66/src/midi/businfo.cpp
  type seq66 (line 53) | namespace seq66
    function e_clock (line 457) | e_clock
    function swap (line 866) | void

FILE: libseq66/src/midi/calculations.cpp
  type seq66 (line 86) | namespace seq66
    function strtoi (line 101) | static int
    function extract_timing_numbers (line 150) | int
    function tokenize_string (line 203) | int
    function pulses_to_string (line 248) | std::string
    function pulses_to_measurestring (line 277) | std::string
    function pulses_to_midi_measures (line 331) | bool
    function pulses_to_measures (line 395) | double
    function pulses_to_time_string (line 424) | std::string
    function pulses_to_time_string (line 461) | std::string
    function pulses_to_hours (line 519) | int
    function trunc_measures (line 534) | double
    function midipulse (line 581) | midipulse
    function midipulse (line 653) | midipulse
    function midi_measures (line 687) | midi_measures
    function midipulse (line 736) | midipulse
    function midipulse (line 794) | midipulse
    function randomize (line 841) | int
    class randomizer (line 867) | class randomizer
      method randomizer (line 879) | randomizer (int seed = -1) :
      method generate (line 888) | int generate ()
      method generate (line 893) | int generate (int range)
    function randomize_uniformly (line 902) | int
    function is_power_of_2 (line 936) | bool
    function log2_of_power_of_2 (line 959) | int
    function pulses_per_substep (line 1040) | int
    function pulses_per_pixel (line 1067) | int
    function beat_power_of_2 (line 1092) | int
    function previous_power_of_2 (line 1124) | int
    function next_power_of_2 (line 1151) | int
    function power (line 1183) | int
    function midibyte (line 1213) | midibyte
    function midibpm (line 1232) | midibpm
    function tempo_us_to_bytes (line 1269) | bool
    function midibyte (line 1322) | midibyte
    function midibpm (line 1344) | midibpm
    function midibpm (line 1366) | midibpm
    function midi_data_adjust (line 1400) | int
    function combine_bytes (line 1437) | unsigned short
    function midilong (line 1454) | midilong
    function midipulse (line 1498) | midipulse
    function wave_func (line 1536) | double
    function unit_truncation (line 1596) | double
    function exp_normalize (line 1629) | double
    function wave_type_name (line 1656) | std::string
    function extract_port_names (line 1729) | bool
    function extract_bus_name (line 1780) | std::string
    function extract_port_name (line 1803) | std::string
    function extract_a2j_port_name (line 1843) | std::string
    function midipulse (line 1881) | midipulse
    function midipulse (line 1897) | midipulse
    function midipulse (line 1911) | midipulse
    function one_max (line 1936) | static double
    function fequal (line 1953) | bool
    function fnotequal (line 1963) | bool
    function flessthan (line 1973) | bool
    function fgreaterthan (line 1983) | bool
    function pitch_value_semitones (line 2026) | double
    function pitch_data_bytes (line 2061) | void
    function pitch_data_bytes_scaled (line 2076) | void

FILE: libseq66/src/midi/controllers.cpp
  type seq66 (line 38) | namespace seq66
    function controller_name (line 185) | std::string
    function set_controller_name (line 207) | void
    function rpn_name (line 237) | std::string
    function rpn_number_to_bytes (line 282) | bool
    function bytes_to_rpn_number (line 296) | short

FILE: libseq66/src/midi/drums.cpp
  type seq66 (line 37) | namespace seq66
    function drums (line 79) | static drums &
    function drum_is_valid (line 102) | static bool drum_is_valid (int drumnumber)
    function add_drum (line 176) | bool
    function set_drums_comment (line 190) | void
    function gm_drum_name (line 216) | std::string
    function drum_name (line 237) | std::string
    function drum_list (line 254) | std::string

FILE: libseq66/src/midi/editable_event.cpp
  type seq66 (line 42) | namespace seq66
    function midishort (line 491) | midishort
    function midishort (line 528) | midishort
    function time_signature_string (line 1281) | std::string
    function time_signature_bytes (line 1310) | bool
    function sysex_string (line 1371) | std::string
    function sysex_bytes (line 1387) | bool

FILE: libseq66/src/midi/editable_events.cpp
  type seq66 (line 38) | namespace seq66
    function editable_events (line 104) | editable_events &
    function midipulse (line 125) | midipulse
    function midipulse (line 269) | midipulse
    function editable_event (line 306) | editable_event &

FILE: libseq66/src/midi/event.cpp
  type seq66 (line 96) | namespace seq66
    function event (line 298) | event &
    function midibpm (line 1367) | midibpm
    function event (line 1658) | event
    function event (line 1713) | event

FILE: libseq66/src/midi/eventlist.cpp
  type seq66 (line 40) | namespace seq66
    function eventlist (line 85) | eventlist &
    function midipulse (line 114) | midipulse
    function midipulse (line 126) | midipulse
    function midipulse (line 1007) | midipulse
    function midipulse (line 1247) | midipulse
    function midipulse (line 3083) | midipulse
    function midipulse (line 3115) | midipulse

FILE: libseq66/src/midi/jack_assistant.cpp
  type seq66 (line 137) | namespace seq66
    function jack_debug_print (line 220) | static void
    function jack_dummy_callback (line 270) | int
    function jack_transport_callback (line 319) | int
    function jack_client_t (line 462) | jack_client_t *
    function jack_set_position (line 542) | void
    function get_jack_client_uuid (line 586) | std::string
    function set_jack_client_property (line 632) | bool
    function set_jack_port_property (line 660) | bool
    function set_jack_port_property (line 682) | bool
    function show_jack_statuses (line 793) | void
    function jack_ticks (line 812) | static double
    function jack_ticks_delta (line 822) | static double
    function jack_sync_callback (line 1480) | int
    function session_event_name (line 1510) | static std::string
    function jack_session_callback (line 1650) | void
    function jack_client_t (line 1969) | jack_client_t *
    function jack_timebase_callback (line 2120) | void
    function jack_transport_shutdown (line 2193) | void
    function jack_state_name (line 2218) | std::string

FILE: libseq66/src/midi/mastermidibase.cpp
  type seq66 (line 42) | namespace seq66
    function e_clock (line 421) | e_clock

FILE: libseq66/src/midi/midi_splitter.cpp
  type seq66 (line 42) | namespace seq66

FILE: libseq66/src/midi/midi_vector.cpp
  type seq66 (line 36) | namespace seq66

FILE: libseq66/src/midi/midi_vector_base.cpp
  type seq66 (line 121) | namespace seq66
    function midipulse (line 631) | midipulse

FILE: libseq66/src/midi/midibase.cpp
  type seq66 (line 53) | namespace seq66

FILE: libseq66/src/midi/midibytes.cpp
  type seq66 (line 40) | namespace seq66
    function midi_bytes_string (line 136) | std::string
    function midibyte (line 174) | midibyte
    function midibooleans (line 197) | midibooleans

FILE: libseq66/src/midi/midifile.cpp
  type seq66 (line 99) | namespace seq66
    function is_proptag (line 215) | static bool
    function midibyte (line 359) | midibyte
    function midishort (line 380) | midishort
    function midilong (line 396) | midilong
    function midilong (line 443) | midilong
    function midilong (line 661) | midilong
    function sequence (line 1833) | sequence *
    function midilong (line 1911) | midilong
    function read_midi_file (line 3760) | bool
    function write_midi_file (line 3832) | bool

FILE: libseq66/src/midi/patches.cpp
  type seq66 (line 37) | namespace seq66
    function patches (line 79) | static patches &
    function add_patch (line 235) | bool
    function set_patches_comment (line 249) | void
    function gm_program_name (line 274) | std::string
    function program_name (line 294) | std::string
    function program_list (line 308) | std::string

FILE: libseq66/src/midi/wrkfile.cpp
  type seq66 (line 88) | namespace seq66
    type wrk_chunk_t (line 95) | enum wrk_chunk_t
    function midishort (line 278) | midishort
    function midilong (line 305) | midilong
    function midilong (line 323) | midilong
    function midilong (line 339) | midilong
    function midilong (line 356) | midilong
    function sequence (line 499) | sequence *

FILE: libseq66/src/os/daemonize.cpp
  type seq66 (line 141) | namespace seq66
    function daemonization (line 225) | daemonization
    function undaemonize (line 370) | void
    function reroute_stdio_to_dev_null (line 392) | bool
    function close_stdio (line 437) | bool
    function reroute_stdio (line 467) | bool
    function session_restart (line 539) | bool
    function session_close (line 553) | bool
    function session_save (line 569) | bool
    function signal_for_save (line 580) | void signal_for_save ()
    function signal_for_exit (line 585) | void signal_for_exit ()
    function signal_for_restart (line 594) | void
    function signal_end_restart (line 600) | void
    function session_handler (line 621) | static void
    function session_setup (line 656) | bool
    function pid_t (line 686) | pid_t
    function pid_exists (line 713) | bool
    function get_pid (line 719) | std::string
    function get_process_name (line 726) | std::string
    function get_process_name (line 742) | std::string
    function get_parent_process_name (line 765) | std::string
    function session_setup (line 780) | bool
    function pid_exists (line 791) | bool
    function pid_t (line 797) | pid_t
    function get_pid (line 803) | std::string
    function get_process_name (line 810) | std::string
    function get_process_name (line 817) | std::string
    function get_parent_process_name (line 828) | std::string

FILE: libseq66/src/os/shellexecute.cpp
  type seq66 (line 42) | namespace seq66
    function command_line (line 49) | bool
    function open_pdf (line 72) | bool
    function open_url (line 91) | bool
    function open_local_url (line 114) | bool
    function open_document (line 122) | bool
    function copy_directory_recursive (line 147) | bool
    function open_document (line 219) | bool
    function copy_directory_recursive (line 259) | bool

FILE: libseq66/src/os/timing.cpp
  type seq66 (line 55) | namespace seq66
    function std_sleep_us (line 62) | int
    function millisleep (line 104) | bool
    function microsleep (line 145) | bool
    function microsleep (line 191) | bool
    function thread_yield (line 223) | void
    function thread_yield (line 231) | void
    function microtime (line 253) | long
    function millitime (line 269) | long
    function microtime (line 302) | long
    function millitime (line 332) | long
    function set_thread_priority (line 376) | bool
    function set_timer_services (line 416) | bool
    function set_thread_priority (line 445) | bool
    function set_timer_services (line 471) | bool

FILE: libseq66/src/play/clockslist.cpp
  type seq66 (line 40) | namespace seq66
    function e_clock (line 196) | e_clock
    function clockslist (line 222) | clockslist &
    function output_port_name (line 236) | std::string
    function bussbyte (line 251) | bussbyte
    function build_output_port_map (line 273) | bool
    function clear_output_port_map (line 308) | void
    function activate_output_port_map (line 315) | void
    function bussbyte (line 354) | bussbyte
    function output_port_map_list (line 397) | std::string

FILE: libseq66/src/play/inputslist.cpp
  type seq66 (line 40) | namespace seq66
    function inputslist (line 202) | inputslist &
    function input_port_name (line 216) | std::string
    function bussbyte (line 231) | bussbyte
    function build_input_port_map (line 250) | bool
 

[
  {
    "path": ".gitignore",
    "chars": 2232,
    "preview": "# .gitignore for Seq66\n#\n# Chris Ahlstrom\n# Updates: 2015-09-12 to 2021-12-12\n\n~$*\n.*\n*~\n*.a\n\\#\nABOUT-NLS\naclocal.m4\n*.a"
  },
  {
    "path": "ChangeLog",
    "chars": 987432,
    "preview": "2026-05-01  Chris <ahlstromcj@gmail.com>\n\n\t* NEWS, RELNOTES, TODO, VERSION, aux-files/ltmain.sh, configure,\n\tconfigure.a"
  },
  {
    "path": "INSTALL",
    "chars": 25803,
    "preview": "INSTALL for Seq66 v. 0.99.24 and above\nChris Ahlstrom\n2015-09-10 to 2026-04-22\n\nGetting Seq66 requires building the code"
  },
  {
    "path": "INSTALL.seq66.on.Ubuntu.md",
    "chars": 5802,
    "preview": "# INSTALL Seq66 for Ubuntu Studio\n\nAuthors: WinkoErades and MQS-mark <p>\nUpdated: 2026-04-22\n\nHere’s a **step-by-step in"
  },
  {
    "path": "Makefile.am",
    "chars": 6667,
    "preview": "#*****************************************************************************\n# Makefile.am (seq66)\n#------------------"
  },
  {
    "path": "NEWS",
    "chars": 80379,
    "preview": "NEWS for Seq66 0.99.24\nChris Ahlstrom\n2015-07-10 to 2026-05-01\n\n# Change Log\n\n## [0.99.24] - 2026-05-01\n\nMitigates issue"
  },
  {
    "path": "README.md",
    "chars": 4214,
    "preview": "# README for Seq66 0.99.24 2026-04-22\n\n__Seq66__ MIDI sequencer/live-looper with a hardware-sampler grid\ninterface; patt"
  },
  {
    "path": "RELNOTES",
    "chars": 1847,
    "preview": "Release Notes for Seq66 v. 0.99.24 2026-05-01 \"Mitt Igation\"\n\nThis release contains some minor feature updates and fixes"
  },
  {
    "path": "ROADMAP.md",
    "chars": 3303,
    "preview": "# ROADMAP for a Possible Seq66 v. 2\n\nChris Ahlstrom\n2022-05-11 to 2022-08-24\n\nThis file is simply some thoughts about th"
  },
  {
    "path": "Seq66cli/Makefile.am",
    "chars": 6861,
    "preview": "#******************************************************************************\n# Makefile.am (seq66cli)\n#--------------"
  },
  {
    "path": "Seq66cli/Seq66cli.pro",
    "chars": 3130,
    "preview": "#******************************************************************************\n# Seq66cli.pro (Seq66cli)\n#-------------"
  },
  {
    "path": "Seq66cli/seq66rtcli.cpp",
    "chars": 8170,
    "preview": "/*\n *  This file is part of seq66.\n *\n *  seq66 is free software; you can redistribute it and/or modify it under the\n * "
  },
  {
    "path": "Seq66qt5/Makefile.am",
    "chars": 7995,
    "preview": "#******************************************************************************\n# Makefile.am (seq66qt5)\n#--------------"
  },
  {
    "path": "Seq66qt5/Seq66qt5.pro",
    "chars": 5883,
    "preview": "#******************************************************************************\n# Seq66qt5.pro (Seq66qt5)\n#-------------"
  },
  {
    "path": "Seq66qt5/seq66qt5.cpp",
    "chars": 6646,
    "preview": "/*\n *  This file is part of seq66.\n *\n *  seq66 is free software; you can redistribute it and/or modify it under the\n * "
  },
  {
    "path": "TODO",
    "chars": 23950,
    "preview": "TO DO for Seq66 0.99.24\nChris Ahlstrom\n2019-04-13 to 2026-04-29\n\n    -   Change the build system to Meson.\n    -   Port "
  },
  {
    "path": "VERSION",
    "chars": 19,
    "preview": "2026-05-01\n0.99.24\n"
  },
  {
    "path": "autogen.sh",
    "chars": 1978,
    "preview": "#!/bin/sh\n#\n#******************************************************************************\n# autogen.sh (Seq66)\n#------"
  },
  {
    "path": "bootstrap",
    "chars": 18848,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# bootstrap (Seq66)\n#-----"
  },
  {
    "path": "bootstrap.help",
    "chars": 2159,
    "preview": "Usage: ./bootstrap [options]    (0.98.9-2022-05-23)\n\n'bootstrap' sets up GNU automake and libtool support for the Seq66 "
  },
  {
    "path": "configure",
    "chars": 863597,
    "preview": "#! /bin/sh\n# From configure.ac Revision: 0.99.\n# Guess values for system-dependent variables and create Makefiles.\n# Gen"
  },
  {
    "path": "configure.ac",
    "chars": 22337,
    "preview": "dnl ***************************************************************************\ndnl configure.ac (Seq66)\ndnl -----------"
  },
  {
    "path": "configure.help",
    "chars": 7378,
    "preview": "`configure' configures Seq66 0.99.12 to adapt to many kinds of systems.\n\nUsage: ./configure [OPTION]... [VAR=VALUE]...\n\n"
  },
  {
    "path": "contrib/DIR_COLORS",
    "chars": 10003,
    "preview": "#******************************************************************************\n# /etc/DIR_COLORS\n#---------------------"
  },
  {
    "path": "contrib/VMPK.conf",
    "chars": 7949,
    "preview": "[Connections]\nAdvancedEnabled=true\nInEnabled=false\nInPort=\nInputDriver=ALSA\nOmniEnabled=false\nOutPort=Midi Through\nOutpu"
  },
  {
    "path": "contrib/Xdefaults.rc",
    "chars": 6985,
    "preview": "!******************************************************************************\n! Xdefaults (~/.Xdefaults)\n!------------"
  },
  {
    "path": "contrib/code/affinity.cpp",
    "chars": 2066,
    "preview": "\n#include <iostream>                     /* std::cout                        */\n#include <mutex>                        "
  },
  {
    "path": "contrib/code/ametro.c",
    "chars": 22321,
    "preview": "/*\n *  ALSA MIDI CLI Metronome\n *  Copyright (C) 2002-2009 Pedro Lopez-Cabanillas <plcl@users.sf.net>\n *  Copyright (C) "
  },
  {
    "path": "contrib/code/function_calls_gnu.c",
    "chars": 3603,
    "preview": "/*\n *  This file is part of seq66.\n *\n *  seq66 is free software; you can redistribute it and/or modify\n *  it under the"
  },
  {
    "path": "contrib/code/function_calls_gnu.h",
    "chars": 1466,
    "preview": "/*\n *  This file is part of seq66.\n *\n *  seq66 is free software; you can redistribute it and/or modify\n *  it under the"
  },
  {
    "path": "contrib/code/make_ametro",
    "chars": 1138,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# make_ametro\n#-----------"
  },
  {
    "path": "contrib/code/qchannelpopup.cpp",
    "chars": 6162,
    "preview": "/*\n *  This file is part of seq66.\n *\n *  seq66 is free software; you can redistribute it and/or modify it under the\n * "
  },
  {
    "path": "contrib/code/qchannelpopup.hpp",
    "chars": 3725,
    "preview": "#if ! defined SEQ66_QCHANNELPOPUP_HPP\n#define SEQ66_QCHANNELPOPUP_HPP\n\n/*\n *  This file is part of seq66.\n *\n *  seq66 i"
  },
  {
    "path": "contrib/code/readbinaryplist.c",
    "chars": 35879,
    "preview": "/*\n *  This file is part of seq66, adapted from the PortMIDI project.\n *\n *  seq66 is free software; you can redistribut"
  },
  {
    "path": "contrib/code/readbinaryplist.h",
    "chars": 3356,
    "preview": "#ifndef SEQ66_READBINARYPLIST_H\n#define SEQ66_READBINARYPLIST_H\n\n/*\n *  This file is part of seq66, adapted from the Por"
  },
  {
    "path": "contrib/code/ring_buffer.hpp",
    "chars": 10891,
    "preview": "#include <initializer_list>\n#include <stdexcept>\n#include <vector>\n\ntemplate <class TYPE>\nclass ring_buffer\n{\n\npublic:\n\n"
  },
  {
    "path": "contrib/code/test/filename_split.cpp",
    "chars": 2165,
    "preview": "\n#if defined SEQ66_PLATFORM_DEBUG\n\n#include \"util/filefunctions.hpp\"\n\nstatic const char * fmt = \"%28s: %28s; %28s; %28s\\"
  },
  {
    "path": "contrib/code/ttymidi.c",
    "chars": 26551,
    "preview": "/*\n    This file is part of ttymidi.\n\n    ttymidi is free software: you can redistribute it and/or modify\n    it under t"
  },
  {
    "path": "contrib/config.rpath",
    "chars": 18442,
    "preview": "#! /bin/sh\n# Output a system dependent set of variables, describing how to set the\n# run time search path of shared libr"
  },
  {
    "path": "contrib/control-map.rc",
    "chars": 11075,
    "preview": "\n[comments]\n\nThis is a test file.\n  \nTreat it with care.\n\n[midi-control-flags]\n\n# These variable values are new with seq"
  },
  {
    "path": "contrib/dd-11/dd-11-notes.log",
    "chars": 3890,
    "preview": "The DD-11 first puts out the following Program Changes:\n\nStatus C0 chan/type 09 d0=0 d1=0\nStatus C0 chan/type 0A d0=0 d1"
  },
  {
    "path": "contrib/gdb/cgdbrc",
    "chars": 330,
    "preview": "# /usr/bin/cgdb\n#\n# The configuration for the cgdb debugger front end.\n#\n# Copy this file to ~/.cgdb/cgdbrc in order to "
  },
  {
    "path": "contrib/gdb/dot-gdbinit",
    "chars": 2006,
    "preview": "#******************************************************************************\n#  gdbinit (~/.gdbinit)\n#---------------"
  },
  {
    "path": "contrib/git/git.text",
    "chars": 196,
    "preview": "Quick Reference for Git Processes on GitHub\nChris Ahlstrom\n2015-09-09 to 2023-07-01\n\nThe content of this file has been m"
  },
  {
    "path": "contrib/git/gitconfig",
    "chars": 574,
    "preview": "[user]\n\tname = User\n\temail = user@gmail.com\n\n[core]\n\texcludesfile = /home/user/.gitignore\n\teditor = vim\n\n[diff]\n\ttool = "
  },
  {
    "path": "contrib/gvim.rc",
    "chars": 1403,
    "preview": "\" The top of this file is similar to .vimrc.\n\n:set nocompatible\n:set nocompatible\n:set autoindent\n:set smartindent\n\n\" Tr"
  },
  {
    "path": "contrib/midi/16-blank-patterns.text",
    "chars": 6652,
    "preview": "File name:      /home/ahlstrom/Home/ca/mls/git/seq66/contrib/midi/16-blank-patterns.text\nNo. of sets:    32\nNo. of track"
  },
  {
    "path": "contrib/midi/2rock.asc",
    "chars": 21317,
    "preview": "MThd 0 1 240\nMTrk\n0 KeySig 0 major\n0 SMPTE 96 0 0 0 0\n0 SeqSpec 00 00 00 6a 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00"
  },
  {
    "path": "contrib/midi/2rock.hex",
    "chars": 13513,
    "preview": "00000000: 4d 54 68 64 00 00 00 06 00 00 00 01 00 f0 4d 54  MThd..........MT\n00000010: 72 6b 00 00 0a fa 00 ff 59 02 00 0"
  },
  {
    "path": "contrib/midi/Carpet_of_the_Sun_karaoke_meta_text.text",
    "chars": 380003,
    "preview": "MThd 1 19 120\nMTrk\n0 Meta SeqName \"Renaissance/Carpet Of The Sun By.Yusaku Kawata\"\n0 Meta Text \"yuyuyu\"\n0 Meta Text \" \\n"
  },
  {
    "path": "contrib/midi/README",
    "chars": 6113,
    "preview": "MIDI Sample and Test Files\nChris Ahlstrom\n2015-09-11 to 2026-04-20\n\nThis directory contains contributed MIDI files for e"
  },
  {
    "path": "contrib/midi/play-pattern-1.text",
    "chars": 1004,
    "preview": "Why did recording the \"New note\" cause the pattern display to be weird with really\nelongated notes?\n\n   0 001:1:001     "
  },
  {
    "path": "contrib/midi/songtest.text",
    "chars": 4699,
    "preview": "File name:      /home/ahlstrom/Home/ca/mls/git/seq66/contrib/midi/songtest.text\nNo. of sets:    1\nNo. of tracks:  5\nMIDI"
  },
  {
    "path": "contrib/midnam/README",
    "chars": 1898,
    "preview": "MIDI Name Format Notes\nChris Ahlstrom\n2021-12-29 to 2021-12-29\n\nThis README provides notes on the Pro Tools MIDNAM forma"
  },
  {
    "path": "contrib/midnam/Roland_MT-32.midnam",
    "chars": 14094,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE MIDINameDocument PUBLIC \"-//MIDI Manufacturers Association//DTD MIDINam"
  },
  {
    "path": "contrib/mkinstalldirs-1.10",
    "chars": 3495,
    "preview": "#! /bin/sh\n# mkinstalldirs --- make directory hierarchy\n\nscriptversion=2006-05-11.19\n\n# Original author: Noah Friedman <"
  },
  {
    "path": "contrib/non/NSM_API.txt",
    "chars": 24583,
    "preview": "http://non.tuxfamily.org/nsm/API.html\n\n****** Non Session Management API ******\n\n     Jonathan Moore Liles <male@tuxfami"
  },
  {
    "path": "contrib/non/messagelist.txt",
    "chars": 5953,
    "preview": "Qta cli srv prox\n x   x   x   x          /error\n         x              /osc/ping\n x   x   x   x          /reply\n x     "
  },
  {
    "path": "contrib/non/nsm-emails.txt",
    "chars": 2256,
    "preview": "NSM Tendrils of Information\nChris Ahlstrom\n2021-03-10 to 2021-09-03\n\n-------------\n\nAnyway, it's nonsensical to start a "
  },
  {
    "path": "contrib/non/nsm-proxy-h2.sh",
    "chars": 642,
    "preview": "# Source: https://github.com/hydrogen-music/hydrogen/issues/32\n#\n# ..of course drumMachine.h2song has to be manually cop"
  },
  {
    "path": "contrib/non/nsm.h",
    "chars": 16621,
    "preview": "/*************************************************************************/\n/* Copyright (C) 2012 Jonathan Moore Liles  "
  },
  {
    "path": "contrib/non/nsm.sh",
    "chars": 2005,
    "preview": "#!/bin/sh\n#------------------------------------------------------------------------------\n##\n# \\file        nsm.sh\n# \\li"
  },
  {
    "path": "contrib/non/nsm_tendrils.txt",
    "chars": 7355,
    "preview": "NSM Notes for Seq66 (nsm_tendrils.txt)\nChris Ahlstrom\n2020-03-14 to 2024-11-06\n\nThese notes are based on the NSM API tex"
  },
  {
    "path": "contrib/notes/INSTALL4Ubuntu.md",
    "chars": 5306,
    "preview": "\n# INSTALL Seq66 for Ubuntu Studio\n\nAuthors: WinkoErades and MQS-mark <p>\nUpdated: 2026-01-16\n\nHere’s a **step-by-step i"
  },
  {
    "path": "contrib/notes/NEWS-template",
    "chars": 612,
    "preview": "\n## [0.99.xx] - 2025-xx-xx\n\n    This release contains ...\n\n### Added\n\n-   Main window and grid.\n-   Pattern editor.\n-   "
  },
  {
    "path": "contrib/notes/RELNOTES-0_99_0.md",
    "chars": 3621,
    "preview": "# Seq66 Release Notes 0.99.0 2022-09-03\n\nThis file lists __major__ changes from version 9.98.0 to 0.99.0 (to catch up).\n"
  },
  {
    "path": "contrib/notes/RPN.text",
    "chars": 8926,
    "preview": "Notes on RPN\nChris Ahlstrom\n2025-01-13 to 2026-04-20\n\nhttps://www.recordingblogs.com/wiki/midi-registered-parameter-numb"
  },
  {
    "path": "contrib/notes/bluez-alsa-notes.text",
    "chars": 2853,
    "preview": "Rough HOWTO On Using Bluetooth Earbuds\nChris Ahlstrom\n2021-08-04 to 2021-08-04\n\nThis is how I got Bluez-ALSA working wit"
  },
  {
    "path": "contrib/notes/bvi.text",
    "chars": 2228,
    "preview": "Cheat Sheet for the bvi Hex Editor\nChris Ahlstrom\n2026-04-22 to 2026-04-22\n\nKey options:\n\n    -R          Read-only view"
  },
  {
    "path": "contrib/notes/clang-macros-freebsd.text",
    "chars": 12270,
    "preview": "#define _LP64 1\n#define __ATOMIC_ACQUIRE 2\n#define __ATOMIC_ACQ_REL 4\n#define __ATOMIC_CONSUME 1\n#define __ATOMIC_RELAXE"
  },
  {
    "path": "contrib/notes/drum_notes_gm_2.text",
    "chars": 1599,
    "preview": "MIDI Drum Notes for GM and GM 2\nChris Ahlstrom\n2021-05-22 to 2021-05-22\n\nThis list comes from:\n\n    https://soundprogram"
  },
  {
    "path": "contrib/notes/event-from-bytes.text",
    "chars": 2143,
    "preview": "SysEx Continuation:\n\nSysEx (System Exclusive) messages in MIDI can be continued across multiple\npackets, often with the "
  },
  {
    "path": "contrib/notes/freebsd.text",
    "chars": 4301,
    "preview": "Notes on FreeBSD and Its Issues\nChris Ahlstrom\n2024-01-13 to 2024-01-13\n\nFreeBSD comes with issues regarding ALSA and JA"
  },
  {
    "path": "contrib/notes/gcc-version.text",
    "chars": 3645,
    "preview": "Setting the gcc and g++ version on Ubuntu and Debian\nChris Ahlstrom\n2019-04-20 to 2020-03-20\n\nI had a problem using std:"
  },
  {
    "path": "contrib/notes/install-directories.text",
    "chars": 1591,
    "preview": "Installation directories for Seq66 in Linux and Windows\nChris Ahlstrom\n2023-05-26 to 2023-07-19\n\nLinux:\n\n    Let PREFIX "
  },
  {
    "path": "contrib/notes/key-maps-dump.text",
    "chars": 30100,
    "preview": "key-maps-dump.text\nChris Ahlstrom\n2023-09-02\n\nThis file shows the maps in the keymap module.  The key-code maps is\nan st"
  },
  {
    "path": "contrib/notes/key-names.text",
    "chars": 2811,
    "preview": "Key Names for Sequencer66\nChris Ahlstrom\n2018-12-04 to 2018-12-04\n\nThis file lists all of the legal (supported) key name"
  },
  {
    "path": "contrib/notes/launchpad.text",
    "chars": 5689,
    "preview": "Quick Reference for Launchpad Mini\nChris Ahlstrom\n2020-08-03 to 2023-04-18\n\nSome of this information was adopted from th"
  },
  {
    "path": "contrib/notes/midi-control-in.text",
    "chars": 8988,
    "preview": "midi-control-in.text\nChris Ahlstrom\n2023-09-02\n\nThis file shows the key assignments (with a modified 'ctrl' file).\n\n[seq"
  },
  {
    "path": "contrib/notes/midi-messages.text",
    "chars": 3867,
    "preview": "Summary of MIDI Messages\nChris Ahlstrom\n2025-10-12 to 2025-10-12\n\n-   Channel Voice Messages\n\n    -   Note Off          "
  },
  {
    "path": "contrib/notes/midi-override-options.text",
    "chars": 442,
    "preview": "Potential Seq66 Options to Override by SeqSpec Data\nChris Ahlstrom\n2025-06-12 to 2025-06-12\n\nConsider a new SeqSpec to h"
  },
  {
    "path": "contrib/notes/msys2-packages.text",
    "chars": 455,
    "preview": "Package to Install for an MSYS2 Build\nChris Ahlstrom\n2024-10-25\n\n    pacman -Syuu\n    pacman -S base-devel git wget p7zi"
  },
  {
    "path": "contrib/notes/pattern-fix-tests.text",
    "chars": 8409,
    "preview": "Thorough Testing of the Pattern-Fix Dialog\nChris Ahlstrom\n2024-11-09 to 2025-01-08\n\nThe test file for pattern-fix is con"
  },
  {
    "path": "contrib/notes/perf-callbacks.text",
    "chars": 5672,
    "preview": "Summary of performer::callbacks usages\nChris Ahlstrom\n2024-12-21 to 2024-12-21\n\nFirst, a summary of the performer::chang"
  },
  {
    "path": "contrib/notes/performance.text",
    "chars": 5733,
    "preview": "Sequencer64:\n\n    Snapshot:\n        Press:          Save current state; let user change playscreen arming.\n        Relea"
  },
  {
    "path": "contrib/notes/pipewire.text",
    "chars": 5158,
    "preview": "Pipewire\nChris Ahlstrom\n2026-01-17 to 2026-01-22\n\nHow to set up to use Pipewire with Seq66 ALSA and JACK support.\n\nPossi"
  },
  {
    "path": "contrib/notes/program-banks.text",
    "chars": 1523,
    "preview": "Chris Ahlstrom\n2025-06-10 to 2025-07-08\n\nIssue #138\n\n    How about each seq66 pattern would always update/save the last "
  },
  {
    "path": "contrib/notes/q-hierarchy.text",
    "chars": 1254,
    "preview": "The Hierarchy of Qt GUI Classes\nChris Ahlstrom\n2021-12-26 to 2021-12-26\n\nThis file simply shows the Seq66 hierarchy of G"
  },
  {
    "path": "contrib/notes/qw-az-keys.text",
    "chars": 17278,
    "preview": "Keys Emitted by Qw(Az)erty Keyboard\nChris Ahlstrom\n2021-08-04 to 2021-12-12\n\n    QWERTY        AZERTY\nx   Key '`' 0x60: "
  },
  {
    "path": "contrib/notes/rearrange-test.text",
    "chars": 1484,
    "preview": "rearrange-test.text\nChris Ahlstrom\n2025-07-03\n\nhttps://midi.org/community/midi-specifications/reordering-simultaneous-ev"
  },
  {
    "path": "contrib/notes/scales-key-chord-handling.text",
    "chars": 2420,
    "preview": "Drawing Note Bars and Disabling Off-Chord or Off-Scale Note Painting\nChris Ahlstrom\n2025-10-12 to 2025-10-12\n\nWe would l"
  },
  {
    "path": "contrib/notes/session-mgrs.text",
    "chars": 5520,
    "preview": "Notes for RaySession and Agordejo Session Managers\nChris Ahlstrom\n2025-01-15 to 2025-01-18\n\nThis document provides a bri"
  },
  {
    "path": "contrib/notes/snapshots.text",
    "chars": 4111,
    "preview": "Snapshot and Other Storage Objects\nChris Ahlstrom\n2023-11-14 to 2023-11-14\n\nThis file reviews how various pattern scenar"
  },
  {
    "path": "contrib/notes/styling.text",
    "chars": 4279,
    "preview": "Ways to Color Seq66\nChris Ahlstrom\n2021-08-04 to 2021-12-12\n\n    1.  Desktop theme:  Select a desktop theme supported by"
  },
  {
    "path": "contrib/notes/win-virtual-keys.text",
    "chars": 8745,
    "preview": "https://learn.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes\n\nThe following table shows the symbolic const"
  },
  {
    "path": "contrib/notes/windows-port-midi.text",
    "chars": 10389,
    "preview": "A Summary of Win32 Multimedia Functions, Structures, MIDI Mapper, and PortMidi\nChris Ahlstrom\n2020-07-05 to 2020-07-11\n\n"
  },
  {
    "path": "contrib/notes/zoom.text",
    "chars": 4961,
    "preview": "Horizontal zoom in Seq66 is basically the number of ticks represented by one\npixel.  It ranges from 1 to 1024 by powers "
  },
  {
    "path": "contrib/scripts/Jack",
    "chars": 7529,
    "preview": "#!/bin/bash\n#-----------------------------------------------------------------------------\n##\n# \\file           Jack\n# \\"
  },
  {
    "path": "contrib/scripts/README",
    "chars": 1758,
    "preview": "Contributed Scripts Directory for Seq66\nChris Ahlstrom\n2021-04-17 to 2023-03-26\n\nThis directory contains scripts that ma"
  },
  {
    "path": "contrib/scripts/alsa.m4",
    "chars": 4392,
    "preview": "dnl Configure Paths for Alsa\ndnl Some modifications by Richard Boulton <richard-alsa@tartarus.org>\ndnl Christopher Lansd"
  },
  {
    "path": "contrib/scripts/audio",
    "chars": 1728,
    "preview": "#!/bin/bash\n#\n# 2024-10-10 to 2024-12-23\n#\n#  Starts/stops mpd, ncmpcpp, and alsamixer. Key bindings can be made:\n#\n#   "
  },
  {
    "path": "contrib/scripts/binfuncs",
    "chars": 2848,
    "preview": "#!/bin/bash\n#------------------------------------------------------------------------------\n##\n# \\file        binfunc\n# "
  },
  {
    "path": "contrib/scripts/bluejack",
    "chars": 3268,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# bluejack\n#--------------"
  },
  {
    "path": "contrib/scripts/build_debug_code.bat",
    "chars": 4036,
    "preview": "@echo off\r\n:: **************************************************************************\r\n:: Seq66 Windows Build-Debug P"
  },
  {
    "path": "contrib/scripts/compositor",
    "chars": 2366,
    "preview": "#!/bin/bash\n##\n# \\file           compositor\n# \\library        Any project\n# \\author         Chris Ahlstrom\n# \\date      "
  },
  {
    "path": "contrib/scripts/configure-clang",
    "chars": 1238,
    "preview": "#!/bin/bash\n#------------------------------------------------------------------------------\n##\n# \\file        configure-"
  },
  {
    "path": "contrib/scripts/conk",
    "chars": 1827,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# Conk\n#------------------"
  },
  {
    "path": "contrib/scripts/debug",
    "chars": 775,
    "preview": "#!/bin/sh\n#\n# This script runs libtool in order to execute a debugger.  For our projects,\n# the setup must avoid the --d"
  },
  {
    "path": "contrib/scripts/dot-xbindkeysrc",
    "chars": 5527,
    "preview": "###########################\n# xbindkeys configuration #\n###########################\n#\n# Microsoft Arc Keyboard and much "
  },
  {
    "path": "contrib/scripts/gdarkseq66",
    "chars": 128,
    "preview": "#!/bin/sh\n#\n# Use dark coloring on qseq66, as configured in qt5ct.\n\nQT_QPA_PLATFORMTHEME=gtk2 qseq66\n\n# vim: ts=3 sw=3 e"
  },
  {
    "path": "contrib/scripts/grayscale.sh",
    "chars": 6143,
    "preview": "#!/bin/bash\n#\n# Chris Ahlstrom\n# 2025-01-05 to 2025-01-05\n#\n# Adapted from https://github.com/bubbleguuum/toggle-monitor"
  },
  {
    "path": "contrib/scripts/gvo",
    "chars": 232,
    "preview": "#!/bin/bash\n#\n# 2026-04-01 to 2026-04-01\n#\n# Runs vim -O in a larger terminal. Under tmux, sometimes one cannot\n# get gv"
  },
  {
    "path": "contrib/scripts/htmldoc",
    "chars": 863,
    "preview": "#!/bin/sh\n#------------------------------------------------------------------------------\n##\n# \\file        htmldoc\n# \\l"
  },
  {
    "path": "contrib/scripts/make-checkout",
    "chars": 2125,
    "preview": "#!/bin/sh\n#------------------------------------------------------------------------------\n##\n# \\file        make-checkou"
  },
  {
    "path": "contrib/scripts/make-qt5-links",
    "chars": 1172,
    "preview": "#!/bin/sh\n#------------------------------------------------------------------------------\n##\n# \\file        make-qt5-lin"
  },
  {
    "path": "contrib/scripts/mutetest",
    "chars": 368,
    "preview": "#!/bin/sh\n#\n# YOSHPATH=\"/usr/bin\"\n\nYOSHPATH=\"/usr/local/bin\"\nROOTPATH=\"/home/ahlstrom/Home/ca/mls/git/\"\nCFGPATH=\"$ROOTPA"
  },
  {
    "path": "contrib/scripts/naming",
    "chars": 805,
    "preview": "#!/bin/bash\n#\n#   This script fixes up the names of MP3 files to shorten them, change spaces\n#   to underscores, etc.  I"
  },
  {
    "path": "contrib/scripts/notemapgen.py",
    "chars": 1333,
    "preview": "#!/usr/bin/python3\n#\n#*****************************************************************************\n##\n#   \\file        "
  },
  {
    "path": "contrib/scripts/ordercp",
    "chars": 428,
    "preview": "#!/bin/bash\n#\n# cd MusicToMove/\n#\n# find . -print0 | sort -zr | xargs -0 cp --parents\n#       --target-directory=/media/"
  },
  {
    "path": "contrib/scripts/qbuild-bash",
    "chars": 3091,
    "preview": "#!/bin/bash\n#------------------------------------------------------------------------------\n##\n# \\file        qbuild\n# \\"
  },
  {
    "path": "contrib/scripts/qbuild.sh",
    "chars": 3975,
    "preview": "#!/bin/sh\n#------------------------------------------------------------------------------\n##\n# \\file        qbuild.sh\n# "
  },
  {
    "path": "contrib/scripts/qbuildwin.sh",
    "chars": 4260,
    "preview": "#!/bin/sh\r\n#------------------------------------------------------------------------------ \r\n# \\file        qbuildwin.sh"
  },
  {
    "path": "contrib/scripts/qtctrun",
    "chars": 390,
    "preview": "#!/bin/bash\n#\n# Run an application using Qt coloring as configured in qt5ct.\n\nQTXCT=\"none\"\ntype qt6ct &> /dev/null\nif [ "
  },
  {
    "path": "contrib/scripts/qtests",
    "chars": 1442,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# qtests (Seq66)\n#--------"
  },
  {
    "path": "contrib/scripts/reconf",
    "chars": 895,
    "preview": "#!/bin/bash\n#------------------------------------------------------------------------------\n##\n# \\file        reconf\n# \\"
  },
  {
    "path": "contrib/scripts/recordpa",
    "chars": 1987,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# recordpa\n#--------------"
  },
  {
    "path": "contrib/scripts/release",
    "chars": 1535,
    "preview": "#!/bin/bash\n#------------------------------------------------------------------------------\n##\n# \\file        release\n# "
  },
  {
    "path": "contrib/scripts/seq66-nsm-proxy",
    "chars": 1237,
    "preview": "#!/bin/bash \n#\n#******************************************************************************\n# seq66-nsm-proxy\n#------"
  },
  {
    "path": "contrib/scripts/seq66.sed",
    "chars": 2164,
    "preview": "#!/usr/bin/sed -i -f\n#\n## \\file          seq66.sed\n#\n#     Quick fixes to some stock changes in going from seq64 to seq6"
  },
  {
    "path": "contrib/scripts/session",
    "chars": 15811,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# session\n#---------------"
  },
  {
    "path": "contrib/scripts/strap_functions",
    "chars": 17362,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# strap_functions (project"
  },
  {
    "path": "contrib/scripts/timid",
    "chars": 1372,
    "preview": "#!/bin/bash\n#------------------------------------------------------------------------------\n##\n# \\file        timid\n# \\l"
  },
  {
    "path": "contrib/scripts/vd",
    "chars": 234,
    "preview": "#!/bin/bash\n#\n# 2026-04-01 to 2026-04-15\n#\n# Runs vim -O in a larger terminal. Under tmux, sometimes one cannot\n# get gv"
  },
  {
    "path": "contrib/scripts/vo",
    "chars": 231,
    "preview": "#!/bin/bash\n#\n# 2026-04-01 to 2026-04-01\n#\n# Runs vim -O in a larger terminal. Under tmux, sometimes one cannot\n# get gv"
  },
  {
    "path": "contrib/scripts/windows/VMS_fixes.reg",
    "chars": 840,
    "preview": "Windows Registry Editor Version 5.00\n \n[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Drivers32]\n\"midi"
  },
  {
    "path": "contrib/scripts/ystart",
    "chars": 2222,
    "preview": "#!/bin/bash\n#\n# Date    2020-11-25\n# Updated 2025-05-29\n#\n# YOSHPATH=\"/usr/bin\"\n#\n# Starts Yoshimi with our oft-used GM "
  },
  {
    "path": "contrib/tests/4x4/README",
    "chars": 1975,
    "preview": "The 4x4 Test\nChris Ahlstrom\n2021-12-13 to 2022-01-02\n\nThe 4x4 test is meant to test the following things:\n\n   -  The usa"
  },
  {
    "path": "contrib/tests/4x4/darkfix.qss",
    "chars": 1415,
    "preview": "/*\n * \\file          textfix.qss\n * \\library       seq66 application\n * \\author        Chris Ahlstrom\n * \\date          "
  },
  {
    "path": "contrib/tests/4x4/qseq66-lp-mini-4x4.ctrl",
    "chars": 29493,
    "preview": "# Seq66 0.90.5 (and above) MIDI control configuration file\n#\n# /home/user/.config/seq66/qseq66-lp-mini-8x8.ctrl\n# Writte"
  },
  {
    "path": "contrib/tests/4x4/qseq66.ctrl",
    "chars": 24954,
    "preview": "# Seq66 0.98.3 MIDI control configuration file\n#\n# /home/ahlstrom/Home/ca/mls/git/seq66/contrib/tests/4x4/qseq66.ctrl\n# "
  },
  {
    "path": "contrib/tests/4x4/qseq66.drums",
    "chars": 2012,
    "preview": "# Seq66 0.98.1 note-mapper ('drums') configuration file\n#\n# /home/user/.config/seq66/4x4/qseq66.drums\n# Written 2021-12-"
  },
  {
    "path": "contrib/tests/4x4/qseq66.mutes",
    "chars": 5343,
    "preview": "# Seq66 0.98.3 mute-groups configuration file\n#\n# /home/ahlstrom/Home/ca/mls/git/seq66/contrib/tests/4x4/qseq66.mutes\n# "
  },
  {
    "path": "contrib/tests/4x4/qseq66.playlist",
    "chars": 1592,
    "preview": "# Seq66 0.98.1 playlist configuration file\n#\n# /home/user/.config/seq66/4x4/qseq66.playlist\n# Written 2021-12-12 11:19:2"
  },
  {
    "path": "contrib/tests/4x4/qseq66.rc",
    "chars": 11079,
    "preview": "# Seq66 0.99.11 main ('rc') configuration file\n#\n# /home/ahlstrom/Home/ca/mls/git/seq66/contrib/tests/4x4/qseq66.rc\n# Wr"
  },
  {
    "path": "contrib/tests/4x4/qseq66.usr",
    "chars": 9324,
    "preview": "# Seq66 0.99.11 user ('usr') configuration file\n#\n# /home/ahlstrom/Home/ca/mls/git/seq66/contrib/tests/4x4/qseq66.usr\n# "
  },
  {
    "path": "contrib/tests/4x4/synthstart",
    "chars": 806,
    "preview": "#!/bin/bash\n#\n# Date    2022-01-02\n# Updated 2022-01-02\n#\n# YOSHPATH=\"/usr/bin\"\n#\n# Starts Yoshimi with our oft-used GM "
  },
  {
    "path": "contrib/valgrind/fontconfig.supp",
    "chars": 131,
    "preview": "# -*- tab-width: 3; indent-tabs-mode: nil -*-\n\n{\n   <insert_a_suppression_name_here>\n   Memcheck:Addr4\n   fun:FcConfigFi"
  },
  {
    "path": "contrib/valgrind/glibc.supp",
    "chars": 379,
    "preview": "# -*- tab-width: 3; indent-tabs-mode: nil -*-\n\n{\n   <insert_a_suppression_name_here>\n   Memcheck:Cond\n   fun:__GI___strc"
  },
  {
    "path": "contrib/valgrind/helgrind-test.sh",
    "chars": 531,
    "preview": "#!/bin/sh\n#\n# Additional options:\n#\n#   --suppressions=contrib/valgrind/seq66.supp\n#   --leak-resolution=high\n\nSCRIPTDIR"
  },
  {
    "path": "contrib/valgrind/kde.supp",
    "chars": 8842,
    "preview": "# See https://www.kdab.com/~dfaure/helgrind.html:\n#\n#   $ cd ~\n#   $ git clone git://anongit.kde.org/kde-dev-scripts\n#  "
  },
  {
    "path": "contrib/valgrind/valgrind-leaks.sh",
    "chars": 228,
    "preview": "#!/bin/sh\n#\n# Additional options:\n#\n#   --suppressions=contrib/valgrind/seq66.supp\n#   --leak-resolution=high\n\nvalgrind "
  },
  {
    "path": "contrib/vim-syntax/c.vim",
    "chars": 12619,
    "preview": "\"******************************************************************************\n\"  c.vim\n\"------------------------------"
  },
  {
    "path": "contrib/vim-syntax/cpp.vim",
    "chars": 5389,
    "preview": "\"******************************************************************************\n\"  cpp.vim\n\"----------------------------"
  },
  {
    "path": "contrib/vim-syntax/meson.vim",
    "chars": 4112,
    "preview": "\" Vim syntax file\n\" Language:\tMeson\n\" License:\tVIM License\n\" Maintainer:\tNirbheek Chauhan <nirbheek.chauhan@gmail.com>\n\""
  },
  {
    "path": "contrib/vim-syntax/syncolor.vim",
    "chars": 2216,
    "preview": "\"******************************************************************************\n\"  syncolor.vim\n\"-----------------------"
  },
  {
    "path": "contrib/vim.rc",
    "chars": 3124,
    "preview": "\"******************************************************************************\n\"  vim.rc (.vimrc)\n\"--------------------"
  },
  {
    "path": "data/Makefile.am",
    "chars": 6827,
    "preview": "#******************************************************************************\n# Makefile.am (seq66/data)\n#------------"
  },
  {
    "path": "data/license.text",
    "chars": 3155,
    "preview": "Seq66 Licensing 0.99.24\r\nChris Ahlstrom\r\n2015-09-10 to 2026-05-01\r\n\r\nAlso see the new LICENSE.* files in the root of the"
  },
  {
    "path": "data/linux/alsa_ports.rc",
    "chars": 1511,
    "preview": "# Seq66 0.99.3 main ('rc') configuration file\n#\n# /home/ahlstrom/.config/seq66/qseq66.rc\n# Written 2023-04-18 13:49:08\n\n"
  },
  {
    "path": "data/linux/ca_ports.rc",
    "chars": 909,
    "preview": "# Seq66 0.91.5 (and above) 'rc' configuration file\n\n[comment]\n\nThese maps were constructed by running various synths and"
  },
  {
    "path": "data/linux/jack/README",
    "chars": 784,
    "preview": "Installed Scripts Directory for Seq66\nChris Ahlstrom\n2021-10-12 to 2025-06-07\n\nThis directory contains scripts that can "
  },
  {
    "path": "data/linux/jack/jack_portmaps.rc",
    "chars": 2383,
    "preview": "# Seq66 0.98.1 main ('rc') configuration file\n#\n# jack_portmaps.rc\n# Written 2021-12-15 12:09:32\n# This file is only an "
  },
  {
    "path": "data/linux/jack/jackctl",
    "chars": 10705,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# jackctl\n#---------------"
  },
  {
    "path": "data/linux/jack/pulseaudio/jack-post-start.sh",
    "chars": 399,
    "preview": "#!/bin/bash\n#\n# From\n#\n# https://archived.forum.manjaro.org/t/how-to-replace-pulseaudio-with-\n#       jack-jack-and-puls"
  },
  {
    "path": "data/linux/jack/pulseaudio/jack-post-stop.sh",
    "chars": 185,
    "preview": "#!/bin/bash\n#\n# From\n#\n# https://archived.forum.manjaro.org/t/how-to-replace-pulseaudio-with-\n#       jack-jack-and-puls"
  },
  {
    "path": "data/linux/jack/pulseaudio/jack-pre-start.sh",
    "chars": 795,
    "preview": "#!/bin/bash\n#\n# From\n#\n# https://archived.forum.manjaro.org/t/how-to-replace-pulseaudio-with-\n#       jack-jack-and-puls"
  },
  {
    "path": "data/linux/jack/pulseaudio/jack-pre-stop.sh",
    "chars": 504,
    "preview": "#!/bin/bash\n#\n# From\n#\n# https://archived.forum.manjaro.org/t/how-to-replace-pulseaudio-with-\n#       jack-jack-and-puls"
  },
  {
    "path": "data/linux/jack/pulseaudio/repulse",
    "chars": 208,
    "preview": "#!/bin/bash\n#\n#  Restarts pulseaudio (Debian-based systems use the --user mode).\n\necho \"Restarting PulseAudio. This acti"
  },
  {
    "path": "data/linux/jack/startjack",
    "chars": 8509,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# startjack\n#-------------"
  },
  {
    "path": "data/linux/jack/startqjack",
    "chars": 3543,
    "preview": "#!/bin/bash\n#\n#******************************************************************************\n# startqjack\n#------------"
  },
  {
    "path": "data/linux/jack_ports.rc",
    "chars": 1259,
    "preview": "# Seq66 0.99.3 main ('rc') configuration file\n#\n# /home/ahlstrom/.config/seq66/qseq66.rc\n# Written 2023-04-18 14:15:12\n\n"
  },
  {
    "path": "data/linux/macros-APC40-mk2.ctrl",
    "chars": 5682,
    "preview": "# This file provides samples, explanations, and ideas for the Akai APC40 Mk2.\n#\n# Copy the [macro-control-out] section a"
  },
  {
    "path": "data/linux/macros-MMC.ctrl",
    "chars": 1666,
    "preview": "# This file provides samples, explanations, and ideas for MMC control.\n#\n# Copy the [macro-control-out] section and past"
  },
  {
    "path": "data/linux/macros-launchpad-mini.ctrl",
    "chars": 604,
    "preview": "# This file provides samples and ideas for the Launchpad Mini.\n#\n# Copy the [macro-control-out] section and paste it int"
  },
  {
    "path": "data/linux/macros-launchpad-pro-mk3.ctrl",
    "chars": 3523,
    "preview": "# This file provides samples, explanations, and ideas for the Launchpad Pro\n# MK3, which is much more complex than the L"
  },
  {
    "path": "data/linux/qseq66-alt-gray.palette",
    "chars": 7058,
    "preview": "# Seq66 0.99.22 (and above) palette configuration file\n#\n# /home/user/.config/seq66/qseq66-alt-gray.palette\n# Written on"
  },
  {
    "path": "data/linux/qseq66-azerty-fr.keymap",
    "chars": 4446,
    "preview": "# Seq66 0.94.0 (and above) keyboard remapping configuration file\n#\n# /home/ahlstrom/.config/seq66/qseq66-azerty-fr.keyma"
  },
  {
    "path": "data/linux/qseq66-azerty.ctrl",
    "chars": 23505,
    "preview": "# Seq66 0.94.1 (and above) MIDI control configuration file\n#\n# /home/user/.config/seq66/qseq66-azerty.ctrl\n# Written 202"
  },
  {
    "path": "data/linux/qseq66-default.palette",
    "chars": 7116,
    "preview": "# Seq66 0.99.22 (and above) palette configuration file\n#\n# /home/ahlstrom/.config/seq66/qseq66.palette\n# Written on 2025"
  },
  {
    "path": "data/linux/qseq66-gray.palette",
    "chars": 6978,
    "preview": "# Seq66 0.99.22 (and above) palette configuration file\n#\n# /home/user/.config/seq66/qseq66-gray.palette\n# Written on 202"
  },
  {
    "path": "data/linux/qseq66-lp-mini-8x8.ctrl",
    "chars": 29493,
    "preview": "# Seq66 0.90.5 (and above) MIDI control configuration file\n#\n# /home/user/.config/seq66/qseq66-lp-mini-8x8.ctrl\n# Writte"
  },
  {
    "path": "data/linux/qseq66-lp-mini-alt.ctrl",
    "chars": 25861,
    "preview": "# Seq66 0.99.21 MIDI control configuration file\n#\n# /home/ahlstrom/.config/seq66/qseq66-lp-mini-alt.ctrl\n# Written 2025-"
  },
  {
    "path": "data/linux/qseq66-lp-mini-swapped.ctrl",
    "chars": 23728,
    "preview": "# Seq66 0.94.1 (and above) MIDI control configuration file\n#\n# /home/user/.config/seq66/qseq66-lp-mini.ctrl\n# Written 20"
  },
  {
    "path": "data/linux/qseq66-lp-mini.ctrl",
    "chars": 23558,
    "preview": "# Seq66 0.94.1 (and above) MIDI control configuration file\n#\n# /home/user/.config/seq66/qseq66-lp-mini.ctrl\n# Written 20"
  },
  {
    "path": "data/linux/qseq66-qwerty-us.keymap",
    "chars": 16211,
    "preview": "# Seq66 0.94.0 (and above) keyboard remapping configuration file\n#\n# /home/ahlstrom/.config/seq66/qseq66-qwerty-us.keyma"
  },
  {
    "path": "data/linux/qseq66-swapped.ctrl",
    "chars": 21675,
    "preview": "# Seq66 0.97.1 MIDI control configuration file\n#\n# /home/user/.config/seq66/qseq66.ctrl\n# Written 2021-10-13 10:08:12\n#\n"
  },
  {
    "path": "data/linux/qseq66.ctrl",
    "chars": 25073,
    "preview": "# Seq66 0.99.3 MIDI control configuration file\n#\n# /home/user/.config/seq66/qseq66.ctrl\n# Written 2023-03-18 10:11:39\n#\n"
  },
  {
    "path": "data/linux/qseq66.drums",
    "chars": 1957,
    "preview": "# Seq66 0.97.2 note-mapper ('drums') configuration file\n#\n# /home/user/.config/seq66/qseq66.drums\n# Written 2021-11-04 1"
  },
  {
    "path": "data/linux/qseq66.mutes",
    "chars": 5357,
    "preview": "# Seq66 0.97.2 mute-groups configuration file\n#\n# /home/ahlstrom/.config/seq66/qseq66.mutes\n# Written 2021-11-04 14:00:2"
  },
  {
    "path": "data/linux/qseq66.palette",
    "chars": 7185,
    "preview": "# Seq66 0.99.22 (and above) palette configuration file\n#\n# /home/ahlstrom/.config/seq66/qseq66.palette\n# Written on 2025"
  },
  {
    "path": "data/linux/qseq66.playlist",
    "chars": 2785,
    "preview": "# Seq66 0.97.7 playlist configuration file\n#\n# /home/ahlstrom/.config/seq66/qseq66.playlist\n# Written 2023-08-06 14:00:2"
  },
  {
    "path": "data/linux/qseq66.rc",
    "chars": 12490,
    "preview": "# Seq66 0.99.6 main ('rc') configuration file\n#\n# /home/user/.config/seq66/qseq66.rc\n# Written 2026-04-17 12:00:00\n#\n# T"
  },
  {
    "path": "data/linux/qseq66.rc.legacy",
    "chars": 18544,
    "preview": "# Seq66 0.90.0 (and above) rc configuration file\n#\n# /home/user/.config/sequencer66/qseq66.rc\n# Written on 2019-03-26 09"
  },
  {
    "path": "data/linux/qseq66.usr",
    "chars": 10148,
    "preview": "# Seq66 0.99.9 user ('usr') configuration file\n#\n# /home/user/.config/seq66/qseq66.usr\n# Written 2024-12-22 06:56:34\n#\n#"
  },
  {
    "path": "data/linux/yoshimi-b4uacuse-gm.state",
    "chars": 368000,
    "preview": "\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE Yoshimi-data>\n<Yoshimi-data Yoshimi-author=\"Alan Ernest Calvert\" Yoshi"
  },
  {
    "path": "data/midi/Carpet_of_the_Sun.text",
    "chars": 2393,
    "preview": "Deconstructing and Reconstructing \"Carpet of the Sun\" with Seq66\nChris Ahlstrom\n2021-05-21 to 2021-05-21\n\n\"Carpet of the"
  },
  {
    "path": "data/midi/EE-qsynth-presets.conf",
    "chars": 501,
    "preview": "# Add this to ~/.config/rncbc.org/Qsynth.conf\n\n[Preset]\nEuropeEndless\\Chan1=0:0:7\nEuropeEndless\\Chan10=9:128:25\nEuropeEn"
  },
  {
    "path": "data/midi/FM/README",
    "chars": 594,
    "preview": "Data/Midi/FM Directory for Seq66 0.99.17\nChris Ahlstrom\n2024-12-27 to 2024-12-27\n\nThis directory contains additional MID"
  },
  {
    "path": "data/midi/Kraftwerk-Europe_Endless.asc",
    "chars": 9729,
    "preview": "MThd 1 19 192\nMTrk\n0 SeqNr 0\n0 Meta SeqName \"Europe Endless by Kraftwerk\"\n0 PrCh ch=2 p=50\n0 TimeSig 4/4 24 8\n0 PrCh ch="
  },
  {
    "path": "data/midi/Kraftwerk-Europe_Endless.text",
    "chars": 8350,
    "preview": "Deconstructing and Reconstructing \"Europe Endless\" with Seq66\nChris Ahlstrom\n2021-04-01 to 2021-07-27\n\nKraftwerk's \"Euro"
  }
]

// ... and 792 more files (download for full content)