mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-05 04:06:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
foot/meson.build

171 lines
4.9 KiB
Meson
Raw Normal View History

rename project to 'foot'
2019-07-11 20:10:59 +02:00
project('foot', 'c',
meson/PKGBUILD: bump version to 1.2.3
2020-03-15 11:28:01 +01:00
version: '1.2.3',
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
license: 'MIT',
meson: dependency: use fallback without variable name Now that both tllist and fcft use meson.override_dependency(), we can use the simpler form of fallback in our dependency call(). This requires meson >= 0.53, tllist >= 1.0.1 and fcft >= 2.0.0
2020-04-24 20:32:37 +02:00
meson_version: '>=0.53.0',
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
default_options: [
meson: bump C standard to c18
2020-04-26 19:39:08 +02:00
'c_std=c18',
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
'warning_level=1',
'werror=true',
'b_ndebug=if-release'])
is_debug_build = get_option('buildtype').startswith('debug')
meson: strip build relative paths from file macros
2020-02-16 14:40:02 +01:00
cc = meson.get_compiler('c')
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
add_project_arguments(
meson: always disable stack-protector and enable strict-aliasing
2020-02-16 14:40:15 +01:00
['-D_GNU_SOURCE=200809L'] + (is_debug_build ? ['-D_DEBUG'] : []) +
cc.get_supported_arguments(
meson: don't set -fno-stack-protector Disabling the stack protection is generally bad, and I can't measure any performance drops with it enabled.
2020-04-04 14:41:43 +02:00
['-fstrict-aliasing',
meson: always disable stack-protector and enable strict-aliasing
2020-02-16 14:40:15 +01:00
'-Wstrict-aliasing',
'-Wno-missing-profile']),
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
language: 'c',
)
initial grid implementation This allows us to render *something*, even though it's inefficient, stupid and far far away from the real thing.
2019-06-13 16:24:35 +02:00
meson: strip build relative paths from file macros
2020-02-16 14:40:02 +01:00
# Compute the relative path used by compiler invocations.
source_root = meson.current_source_dir().split('/')
build_root = meson.build_root().split('/')
relative_dir_parts = []
i = 0
in_prefix = true
foreach p : build_root
if i >= source_root.length() or not in_prefix or p != source_root[i]
in_prefix = false
relative_dir_parts += '..'
endif
i += 1
endforeach
i = 0
in_prefix = true
foreach p : source_root
if i >= build_root.length() or not in_prefix or build_root[i] != p
in_prefix = false
relative_dir_parts += p
endif
i += 1
endforeach
relative_dir = join_paths(relative_dir_parts) + '/'
if cc.has_argument('-fmacro-prefix-map=/foo=')
add_project_arguments('-fmacro-prefix-map=@0@='.format(relative_dir), language: 'c')
endif
meson: we now require -lm
2019-12-05 19:35:54 +01:00
math = cc.find_library('m')
wip: initial input handling
2019-06-19 10:04:47 +02:00
threads = dependency('threads')
meson: add pixman dependency
2019-08-15 21:21:22 +02:00
pixman = dependency('pixman-1')
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
wayland_protocols = dependency('wayland-protocols')
wayland_client = dependency('wayland-client')
wayland_cursor = dependency('wayland-cursor')
xkb = dependency('xkbcommon')
unicode-combine: remove utf8proc dependency We only used utf8proc to try to pre-compose a glyph from a base and combining character. We can do this ourselves by using a pre-compiled table of valid pre-compositions. This table isn't _that_ big, and binary searching it is fast. That is, for a very small amount of code, and not too much extra RO data, we can get rid of the utf8proc dependency.
2020-05-02 17:29:00 +02:00
add_project_arguments('-DFOOT_UNICODE_PRECOMPOSE=@0@'.format(
unicode-combining: store seen combining chains "globally" in the term struct Instead of storing combining data per cell, realize that most combinations are re-occurring and that there's lots of available space left in the unicode range, and store seen base+combining combinations chains in a per-terminal array. When we encounter a combining character, we first try to pre-compose, like before. If that fails, we then search for the current base+combining combo in the list of previously seen combinations. If not found there either, we allocate a new combo and add it to the list. Regardless, the result is an index into this array. We store this index, offsetted by COMB_CHARS_LO=0x40000000ul in the cell. When rendering, we need to check if the cell character is a plain character, or if it's a composed character (identified by checking if the cell character is >= COMB_CHARS_LO). Then we render the grapheme pretty much like before.
2020-05-03 11:03:22 +02:00
get_option('unicode-precompose')), language: 'c')
utf8: add support for unicode combining characters This feature lets foot combine e.g. "a\u0301" to "á". We first check if the current character (that we're about to print) is a combining character, by checking if it's in one of the following ranges: * Combining Diacritical Marks (0300–036F), since version 1.0, with modifications in subsequent versions down to 4.1 * Combining Diacritical Marks Extended (1AB0–1AFF), version 7.0 * Combining Diacritical Marks Supplement (1DC0–1DFF), versions 4.1 to 5.2 * Combining Diacritical Marks for Symbols (20D0–20FF), since version 1.0, with modifications in subsequent versions down to 5.1 * Combining Half Marks (FE20–FE2F), versions 1.0, with modifications in subsequent versions down to 8.0 If it is, we check if the last cell appears to contain a valid symbol, and if so, we attempt to compose (combine) the last cell with the current character, using utf8proc. If the result is a combined character, we replace the content in the previous cell with the new, combined character. Thus, if you select and copy the printed character, you would get e.g. "\u00e1" instead of "a\u0301". This feature can be disabled. By default, it is enabled if the utf8proc library is found, but can be explicitly disabled, or enabled, with 'meson -Dunicode-combining=disabled|enabled'.
2020-04-27 12:13:30 +02:00
meson: dependency: use fallback without variable name Now that both tllist and fcft use meson.override_dependency(), we can use the simpler form of fallback in our dependency call(). This requires meson >= 0.53, tllist >= 1.0.1 and fcft >= 2.0.0
2020-04-24 20:32:37 +02:00
tllist = dependency('tllist', version: '>=1.0.1', fallback: 'tllist')
fcft = dependency('fcft', version: ['>=2.0.0', '<2.1.0'], fallback: 'fcft')
meson: tllist/fcft: use system dependency first, fallback to subprojects
2019-12-01 16:11:35 +01:00
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
wayland_protocols_datadir = wayland_protocols.get_pkgconfig_variable('pkgdatadir')
wscanner = dependency('wayland-scanner', native: true)
wscanner_prog = find_program(
wscanner.get_pkgconfig_variable('wayland_scanner'), native: true)
wl_proto_headers = []
wl_proto_src = []
foreach prot : [
wayland_protocols_datadir + '/stable/xdg-shell/xdg-shell.xml',
main: request server-side decorations
2019-08-30 17:55:45 +02:00
wayland_protocols_datadir + '/unstable/xdg-decoration/xdg-decoration-unstable-v1.xml',
output: initial support for output scaling * Not updated run-time; only scale at start up used * Multiple monitors (outputs) not supported, as we can't track which output we're on (yet).
2019-08-12 21:22:38 +02:00
wayland_protocols_datadir + '/unstable/xdg-output/xdg-output-unstable-v1.xml',
selection: add support for pasting *from* primary
2019-07-11 17:02:21 +02:00
wayland_protocols_datadir + '/unstable/primary-selection/primary-selection-unstable-v1.xml',
wayland: optionally use the presentation time protocol to measure input lag This adds a flag, -p,--presentation-timings, that enables input lag measuring using the presentation time Wayland protocol. When enabled, we store a timestamp when we *send* a key to the slave. Then, when we commit a frame for rendering to the compositor, we request presentation feedback. We also store a timestamp for when the frame was committed. The 'presented' callback then looks at the input and commit timestamps, and compares it with the presented timestamp. The delay is logged at INFO when the delay was less than one frame interval, at WARN when it was one frame interval, and at ERR when it was two or more frame intervals. We also update statistic counters that we log when foot is shut down.
2019-12-31 15:39:40 +01:00
wayland_protocols_datadir + '/stable/presentation-time/presentation-time.xml',
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
]
wl_proto_headers += custom_target(
prot.underscorify() + '-client-header',
output: '@BASENAME@.h',
input: prot,
command: [wscanner_prog, 'client-header', '@INPUT@', '@OUTPUT@'])
wl_proto_src += custom_target(
prot.underscorify() + '-private-code',
output: '@BASENAME@.c',
input: prot,
command: [wscanner_prog, 'private-code', '@INPUT@', '@OUTPUT@'])
endforeach
unicode-combining: store seen combining chains "globally" in the term struct Instead of storing combining data per cell, realize that most combinations are re-occurring and that there's lots of available space left in the unicode range, and store seen base+combining combinations chains in a per-terminal array. When we encounter a combining character, we first try to pre-compose, like before. If that fails, we then search for the current base+combining combo in the list of previously seen combinations. If not found there either, we allocate a new combo and add it to the list. Regardless, the result is an index into this array. We store this index, offsetted by COMB_CHARS_LO=0x40000000ul in the cell. When rendering, we need to check if the cell character is a plain character, or if it's a composed character (identified by checking if the cell character is >= COMB_CHARS_LO). Then we render the grapheme pretty much like before.
2020-05-03 11:03:22 +02:00
if get_option('unicode-precompose')
meson: don't generate pre-compose table when -Dunicode-precompose=false
2020-05-02 18:43:13 +02:00
generate_unicode_precompose_sh = files('scripts/generate-unicode-precompose.sh')
unicode_data = custom_target(
'unicode-data',
input: 'UnicodeData.txt',
output: 'unicode-compose-table.h',
command: [generate_unicode_precompose_sh, '@INPUT@', '@OUTPUT@'])
else
unicode_data = []
endif
meson: generate unicode compose table This replaces the pre-generated table used up until now.
2020-05-02 18:29:39 +02:00
meson: fix version generation from git run_command() was only run at configure time, meaning the generated version (that was passed on to the sources via -DFUZZEL_VERSION) became stale. Fix by implementing a shell script that generates a header file, and wrap this in a custom target that is run every time (but the generated file is only updated when the version changes)
2019-10-19 22:09:52 +02:00
generate_version_sh = files('generate-version.sh')
version = custom_target(
'generate_version',
build_always_stale: true,
output: 'version.h',
command: [generate_version_sh, meson.project_version(), '@SOURCE_DIR@', '@OUTPUT@'])
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
executable(
rename project to 'foot'
2019-07-11 20:10:59 +02:00
'foot',
async: add async_write(), a write primitive to write to a NONBLOCK:ing FD
2019-11-04 13:45:38 +01:00
'async.c', 'async.h',
base64: initial base64 decode implementation
2019-07-19 11:11:25 +02:00
'base64.c', 'base64.h',
conf: initial support for configuration file * Look for configuration file in (in this order): - XDG_CONFIG_HOME/footrc - ~/.config/footrc * Currently supports setting the font
2019-07-16 11:52:22 +02:00
'config.c', 'config.h',
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
'commands.c', 'commands.h',
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
'csi.c', 'csi.h',
dcs: initial handling of DCS in general Add data structure to term->vt. This structure tracks the free-form data that is passed-through, and the handler to call at the end. Intermediates and parameters are collected by the normal VT parser. Then, when we enter the passthrough state, we call dcs_hook(). This function checks the intermediate(s) and parameters, and selects the appropriate unhook handler (and optionally does some execution already). In passthrough mode, we simply append strings to an internal buffer. This might have to be changed in the future, if we need to support a DCS that needs to execute as we go. In unhook (i.e. when the DCS is terminated), we execute the unhook handler. As a proof-of-concept, handlers for BSU/ESU (Begin/End Synchronized Update) has been added (but are left unimplemented).
2020-01-12 11:55:22 +01:00
'dcs.c', 'dcs.h',
fdm: use the FDM's poll loop
2019-10-27 11:46:18 +01:00
'fdm.c', 'fdm.h',
wip: vt parsing: break out grid operating functions
2019-06-17 19:33:10 +02:00
'grid.c', 'grid.h',
wip: initial input handling
2019-06-19 10:04:47 +02:00
'input.c', 'input.h',
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
'log.c', 'log.h',
'main.c',
selection: break out isword() to a new file
2019-12-03 19:16:05 +01:00
'misc.c', 'misc.h',
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
'osc.c', 'osc.h',
search: enable/disable weston sub-surface desync quirk when rendering search box
2020-03-01 13:06:00 +01:00
'quirks.c', 'quirks.h',
render: break out rendering functions to render.{c,h}
2019-07-05 10:16:56 +02:00
'render.c', 'render.h',
search: wip: re-direct input while searching, and build a search buffer This adds a new state, 'is_searching'. While active, input is re-directed, and stored in a search buffer. In the future, we'll use this buffer and search for its content in the scrollback buffer, and move the view and create a selection on matches. When rendering in 'is_searching', everything is dimmed. In the future, we'll render the current search buffer on-top of the dimmed "regular" terminal output.
2019-08-27 17:23:28 +02:00
'search.c', 'search.h',
selection: add a selection API
2019-07-11 09:51:51 +02:00
'selection.c', 'selection.h',
server: implement a --server mode In this mode, foot listens on a UNIX socket and creates terminal windows when clients connect. A connecting client sends argc/argv to the server, and the server instantiates a new terminal window. When the terminal window is closed, the exit code is sent back to the client.
2019-11-01 20:37:22 +01:00
'server.c', 'server.h',
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
'shm.c', 'shm.h',
sixel: initial support This implements basic parsing of sixel data. Lots of limitations and temporary solutions as this is still work-in-progress: * Maximum image size hardcoded to 800x800 * No HLS color format support * Image is always rendered at 0x0 in the terminal
2020-02-21 21:53:23 +01:00
'sixel.c', 'sixel.h',
sixel: add HLS color format support
2020-02-22 21:18:55 +01:00
'sixel-hls.c', 'sixel-hls.h',
Set up pseudo terminal and fork slave
2019-06-13 15:19:10 +02:00
'slave.c', 'slave.h',
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
'terminal.c', 'terminal.h',
slave: break out command line tokenizer
2019-07-17 09:46:45 +02:00
'tokenize.c', 'tokenize.h',
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
'vt.c', 'vt.h',
wayland: implement wayl_destroy()
2019-10-27 15:57:23 +01:00
'wayland.c', 'wayland.h',
meson: generate unicode compose table This replaces the pre-generated table used up until now.
2020-05-02 18:29:39 +02:00
wl_proto_src + wl_proto_headers, version, unicode_data,
unicode-combine: remove utf8proc dependency We only used utf8proc to try to pre-compose a glyph from a base and combining character. We can do this ourselves by using a pre-compiled table of valid pre-compositions. This table isn't _that_ big, and binary searching it is fast. That is, for a very small amount of code, and not too much extra RO data, we can get rid of the utf8proc dependency.
2020-05-02 17:29:00 +02:00
dependencies: [math, threads, pixman, wayland_client, wayland_cursor, xkb, tllist, fcft],
initial commit: maps an XDG toplevel window
2019-06-12 20:08:54 +02:00
install: true)
meson: install foot.desktop
2019-07-15 15:47:45 +02:00
client: a standalone binary that connects to a foot --server
2019-11-01 20:39:34 +01:00
executable(
'footclient',
'client.c',
meson: add 'version' dependency to footclient footclient (`client.c`, to be precise) includes `version.h`, which is a generated file.
2019-11-18 17:01:34 +01:00
'log.c', 'log.h', version,
client: a standalone binary that connects to a foot --server
2019-11-01 20:39:34 +01:00
install: true)
terminfo: intitial terminfo specification
2019-07-18 14:00:33 +02:00
custom_target(
'terminfo',
output: 'f',
input: 'foot.info',
terminfo: add XM (mouse initialization)
2019-07-21 20:46:17 +02:00
command: ['tic', '-x', '-o', '@OUTDIR@', '-e', 'foot,foot-direct', '@INPUT@'],
terminfo: intitial terminfo specification
2019-07-18 14:00:33 +02:00
install: true,
install_dir: join_paths(get_option('datadir'), 'terminfo'))
desktop: add foot-server.desktop - launches a foot server instance
2020-01-24 22:27:11 +01:00
install_data('foot.desktop', 'foot-server.desktop', install_dir: join_paths(get_option('datadir'), 'applications'))
meson: install footrc example file to $datadir/foot/footrc
2019-09-20 18:06:54 +02:00
install_data('footrc', install_dir: join_paths(get_option('datadir'), 'foot'))
doc: add foot.1 man page
2019-08-11 20:54:28 +02:00
completions: add zsh completions
2019-10-20 11:54:58 +02:00
subdir('completions')
doc: add foot.1 man page
2019-08-11 20:54:28 +02:00
subdir('doc')
meson: emit a 'summary()' at the end
2020-05-01 12:32:10 +02:00
summary(
{
unicode-combining: store seen combining chains "globally" in the term struct Instead of storing combining data per cell, realize that most combinations are re-occurring and that there's lots of available space left in the unicode range, and store seen base+combining combinations chains in a per-terminal array. When we encounter a combining character, we first try to pre-compose, like before. If that fails, we then search for the current base+combining combo in the list of previously seen combinations. If not found there either, we allocate a new combo and add it to the list. Regardless, the result is an index into this array. We store this index, offsetted by COMB_CHARS_LO=0x40000000ul in the cell. When rendering, we need to check if the cell character is a plain character, or if it's a composed character (identified by checking if the cell character is >= COMB_CHARS_LO). Then we render the grapheme pretty much like before.
2020-05-03 11:03:22 +02:00
'Unicode precompose': get_option('unicode-precompose'),
meson: emit a 'summary()' at the end
2020-05-01 12:32:10 +02:00
},
bool_yn: true
)
Reference in a new issue Copy permalink