# Copyright (c) 2012 David Herrmann <dh.herrmann@googlemail.com>
#
-ACLOCAL_AMFLAGS = -I m4
-SUBDIRS = \
- .
+#
+# Library Version Numbers
+#
+
+LIBELOOP_CURRENT = 1
+LIBELOOP_REVISION = 0
+LIBELOOP_AGE = 0
+
+LIBTSM_CURRENT = 1
+LIBTSM_REVISION = 0
+LIBTSM_AGE = 0
+
+LIBUTERM_CURRENT = 1
+LIBUTERM_REVISION = 0
+LIBUTERM_AGE = 0
+
+#
+# Global Configurations and Initializations
+#
+
+ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
+AM_MAKEFLAGS = --no-print-directory
+AUTOMAKE_OPTIONS = color-tests
+
+SUBDIRS = .
+
+.DELETE_ON_ERROR:
+
include_HEADERS =
EXTRA_DIST = \
README \
COPYING \
NEWS \
docs/kmscon.service \
- docs/kmsconvt@.service
+ docs/kmsconvt@.service \
+ docs/pc/libeloop.pc.in \
+ docs/pc/libtsm.pc.in \
+ docs/pc/libuterm.pc.in \
+ docs/sym/libeloop.sym \
+ docs/sym/libtsm.sym \
+ docs/sym/libuterm.sym
CLEANFILES =
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA =
bin_PROGRAMS =
check_PROGRAMS =
-noinst_PROGRAMS = \
- genshader \
- genunifont
-noinst_LTLIBRARIES =
+noinst_PROGRAMS =
lib_LTLIBRARIES =
+noinst_LTLIBRARIES =
-moduledir = @libdir@/kmscon
+moduledir = $(libdir)/kmscon
module_LTLIBRARIES =
#
#
AM_CFLAGS = \
- -Wall
+ -Wall \
+ -pipe \
+ -fno-common \
+ -ffast-math \
+ -fdiagnostics-show-option \
+ -fno-strict-aliasing \
+ -fvisibility=hidden \
+ -ffunction-sections \
+ -fdata-sections \
+ -fstack-protector
AM_CPPFLAGS = \
-DBUILD_MODULE_DIR='"$(moduledir)"' \
-include $(top_builddir)/config.h \
-I $(srcdir)/src
AM_LDFLAGS = \
- -Wl,--as-needed
+ -Wl,--as-needed \
+ -Wl,--gc-sections \
+ -Wl,-z,relro \
+ -Wl,-z,now
if BUILD_ENABLE_DEBUG
AM_CFLAGS += -g
endif
#
-# SHL - Static Helper Library
-# The SHL subsystem contains several small code pieces used all over kmscon and
-# other applications.
-#
-# Simply include $(SHL_*) in your source-file list.
-# SHL_MISC needs xkbcommon
-# SHL_REGISTER needs pthread
-#
-
-SHL_DLIST = \
- src/shl_dlist.h
-SHL_ARRAY = \
- src/shl_array.h
-SHL_HASHTABLE = \
- src/shl_hashtable.h \
- external/htable.h \
- external/htable.c
-SHL_RING = \
- src/shl_ring.h
-SHL_TIMER = \
- src/shl_timer.h
-SHL_LLOG = \
- src/shl_llog.h
-SHL_HOOK = \
- src/shl_hook.h \
- $(SHL_DLIST)
-SHL_MISC = \
- src/shl_misc.h
-SHL_REGISTER = \
- src/shl_register.h \
- $(SHL_DLIST)
-
-#
# GIT-HEAD helper
# The file ./src/githead.h contains a constant BUILD_GIT_HEAD which is defined
# to the string returned by "git describe". We need to adjust this string for
GITHEAD:=$(shell $(emptyvariable)"$(srcdir)/src/genversion.sh" "$(srcdir)/src/githead.h")
#
+# SHL - Static Helper Library
+# The SHL subsystem contains several small code pieces used all over kmscon and
+# other applications.
+#
+
+noinst_LTLIBRARIES += libshl.la
+
+libshl_la_SOURCES = \
+ src/shl_dlist.h \
+ src/shl_array.h \
+ src/shl_hashtable.h \
+ external/htable.h \
+ external/htable.c \
+ src/shl_ring.h \
+ src/shl_timer.h \
+ src/shl_llog.h \
+ src/shl_hook.h \
+ src/shl_misc.h \
+ src/shl_register.h
+libshl_la_CPPFLAGS = \
+ $(AM_CPPFLAGS) \
+ $(XKBCOMMON_CFLAGS) \
+ -pthread
+libshl_la_LDFLAGS = \
+ $(AM_LDFLAGS) \
+ -pthread
+libshl_la_LIBADD = \
+ $(AM_LIBADD) \
+ $(XKBCOMMON_LIBS)
+
+#
# libeloop
# This library contains the whole event-loop implementation of kmscon. It is
# compiled into a separate object to allow using it in several other programs.
endif
libeloop_la_SOURCES = \
- $(SHL_DLIST) \
- $(SHL_LLOG) \
- $(SHL_HOOK) \
src/eloop.h \
src/eloop.c
-libeloop_la_CPPFLAGS = \
- $(AM_CPPFLAGS)
-libeloop_la_LIBADD =
+libeloop_la_LIBADD = libshl.la
+libeloop_la_CPPFLAGS = $(AM_CPPFLAGS)
+EXTRA_libeloop_la_DEPENDENCIES = ${top_srcdir}/docs/sym/libeloop.sym
libeloop_la_LDFLAGS = \
- -version-info 1:0:0
+ $(AM_LDFLAGS) \
+ -version-info $(LIBELOOP_CURRENT):$(LIBELOOP_REVISION):$(LIBELOOP_AGE) \
+ -Wl,--version-script=$(top_srcdir)/docs/sym/libeloop.sym
if BUILD_ENABLE_ELOOP_DBUS
external/dbus-common.h \
external/dbus-loop.h \
external/dbus-loop.c
-libeloop_la_CPPFLAGS += \
- $(DBUS_CFLAGS)
-libeloop_la_LIBADD += \
- $(DBUS_LIBS)
+libeloop_la_CPPFLAGS += $(DBUS_CFLAGS)
+libeloop_la_LIBADD += $(DBUS_LIBS)
endif
#
#
if BUILD_ENABLE_TSM
-lib_LTLIBRARIES += \
- libtsm.la
+lib_LTLIBRARIES += libtsm.la
include_HEADERS += \
src/tsm_screen.h \
src/tsm_unicode.h \
src/tsm_vte.h
-pkgconfig_DATA += \
- docs/pc/libtsm.pc
+pkgconfig_DATA += docs/pc/libtsm.pc
endif
libtsm_la_SOURCES = \
- $(SHL_LLOG) \
- $(SHL_TIMER) \
- $(SHL_ARRAY) \
- $(SHL_HASHTABLE) \
src/tsm_screen.h \
src/tsm_screen.c \
src/tsm_unicode.h \
libtsm_la_CPPFLAGS = \
$(AM_CPPFLAGS) \
$(XKBCOMMON_CFLAGS)
-libtsm_la_LDFLAGS = \
+libtsm_la_LIBADD = \
$(XKBCOMMON_LIBS) \
- -version-info 1:0:0
+ libshl.la
+EXTRA_libtsm_la_DEPENDENCIES = ${top_srcdir}/docs/sym/libtsm.sym
+libtsm_la_LDFLAGS = \
+ $(AM_LDFLAGS) \
+ -version-info $(LIBTSM_CURRENT):$(LIBTSM_REVISION):$(LIBTSM_AGE) \
+ -Wl,--version-script="$(top_srcdir)/docs/sym/libtsm.sym"
#
# libuterm
endif
libuterm_la_SOURCES = \
- $(SHL_DLIST) \
- $(SHL_HOOK) \
- $(SHL_MISC) \
- $(SHL_TIMER) \
src/uterm_input.h \
src/uterm_monitor.h \
src/uterm_video.h \
$(XKBCOMMON_CFLAGS)
libuterm_la_LIBADD = \
$(XKBCOMMON_LIBS) \
- libeloop.la
+ libeloop.la \
+ libshl.la
+EXTRA_libuterm_la_DEPENDENCIES = ${top_srcdir}/docs/sym/libuterm.sym
libuterm_la_LDFLAGS = \
- -version-info 1:0:0
+ $(AM_LDFLAGS) \
+ -version-info $(LIBUTERM_CURRENT):$(LIBUTERM_REVISION):$(LIBUTERM_AGE) \
+ -Wl,--version-script="$(top_srcdir)/docs/sym/libuterm.sym"
if BUILD_ENABLE_MULTI_SEAT
libuterm_la_SOURCES += src/uterm_systemd.c
endif
if BUILD_ENABLE_VIDEO_DRM3D
+noinst_PROGRAMS += genshader
libuterm_la_SOURCES += \
src/uterm_drm3d_internal.h \
src/uterm_drm3d_video.c \
src/static_gl.h \
src/static_gl_math.c \
src/static_gl_shader.c
-nodist_libuterm_la_SOURCES += \
- src/static_shaders.c
+nodist_libuterm_la_SOURCES += src/static_shaders.c
libuterm_la_CPPFLAGS += \
$(DRM_CFLAGS) \
$(EGL_CFLAGS) \
if BUILD_ENABLE_FONT_UNIFONT
module_LTLIBRARIES += mod-unifont.la
+noinst_PROGRAMS += genunifont
endif
mod_unifont_la_SOURCES = \
src/kmscon_mod_unifont.c
nodist_mod_unifont_la_SOURCES = \
src/font_unifont_data.c
+mod_unifont_la_LIBADD = libshl.la
mod_unifont_la_LDFLAGS = \
+ $(AM_LDFLAGS) \
-module \
-avoid-version
endif
mod_freetype2_la_SOURCES = \
- $(SHL_DLIST) \
- $(SHL_HASHTABLE) \
src/kmscon_module_interface.h \
src/githead.h \
src/font_freetype2.c \
mod_freetype2_la_LIBADD = \
$(FREETYPE2_LIBS) \
-lpthread \
- libtsm.la
+ libtsm.la \
+ libshl.la
mod_freetype2_la_LDFLAGS = \
+ $(AM_LDFLAGS) \
-module \
-avoid-version
endif
mod_pango_la_SOURCES = \
- $(SHL_DLIST) \
- $(SHL_HASHTABLE) \
src/kmscon_module_interface.h \
src/githead.h \
src/font_pango.c \
mod_pango_la_LIBADD = \
$(PANGO_LIBS) \
-lpthread \
- libtsm.la
+ libtsm.la \
+ libshl.la
mod_pango_la_LDFLAGS = \
+ $(AM_LDFLAGS) \
-module \
-avoid-version
src/githead.h \
src/text_bbulk.c \
src/kmscon_mod_bbulk.c
+mod_bbulk_la_LIBADD = libshl.la
mod_bbulk_la_LDFLAGS = \
+ $(AM_LDFLAGS) \
-module \
-avoid-version
if BUILD_ENABLE_RENDERER_GLTEX
module_LTLIBRARIES += mod-gltex.la
+noinst_PROGRAMS += genshader
endif
mod_gltex_la_SOURCES = \
$(AM_CPPFLAGS) \
$(GLES2_CFLAGS)
mod_gltex_la_LIBADD = \
- $(GLES2_LIBS)
+ $(GLES2_LIBS) \
+ libshl.la
mod_gltex_la_LDFLAGS = \
+ $(AM_LDFLAGS) \
-module \
-avoid-version
$(AM_CPPFLAGS) \
$(CAIRO_CFLAGS)
mod_cairo_la_LIBADD = \
- $(CAIRO_LIBS)
+ $(CAIRO_LIBS) \
+ libshl.la
mod_cairo_la_LDFLAGS = \
+ $(AM_LDFLAGS) \
-module \
-avoid-version
$(AM_CPPFLAGS) \
$(PIXMAN_CFLAGS)
mod_pixman_la_LIBADD = \
- $(PIXMAN_LIBS)
+ $(PIXMAN_LIBS) \
+ libshl.la
mod_pixman_la_LDFLAGS = \
+ $(AM_LDFLAGS) \
-module \
-avoid-version
endif
kmscon_SOURCES = \
- $(SHL_DLIST) \
- $(SHL_MISC) \
- $(SHL_ARRAY) \
- $(SHL_HASHTABLE) \
- $(SHL_RING) \
- $(SHL_TIMER) \
- $(SHL_HOOK) \
- $(SHL_REGISTER) \
src/githead.h \
src/conf.h \
src/conf.c \
$(XKBCOMMON_LIBS) \
libeloop.la \
libuterm.la \
+ libshl.la \
-lpthread \
-ldl
kmscon_LDFLAGS = \
+ $(AM_LDFLAGS) \
-rdynamic
if BUILD_ENABLE_SESSION_DUMMY
endif
wlterm_SOURCES = \
- $(SHL_MISC) \
- $(SHL_ARRAY) \
- $(SHL_DLIST) \
- $(SHL_HOOK) \
- $(SHL_REGISTER) \
- $(SHL_HASHTABLE) \
src/wlt_main.h \
src/wlt_main.c \
src/wlt_toolkit.h \
$(XKBCOMMON_LIBS) \
libeloop.la \
libtsm.la \
+ libshl.la \
-lpthread
#
src/conf.c \
tests/test_include.h
test_cflags = \
+ $(AM_CPPFLAGS) \
$(XKBCOMMON_CFLAGS)
test_libs = \
$(XKBCOMMON_LIBS) \
test_output_SOURCES = \
$(test_sources) \
tests/test_output.c
-test_output_CPPFLAGS = \
- $(AM_CPPFLAGS) \
- $(test_cflags)
+test_output_CPPFLAGS = $(test_cflags)
test_output_LDADD = \
$(test_libs) \
libuterm.la
test_vt_SOURCES = \
$(test_sources) \
tests/test_vt.c
-test_vt_CPPFLAGS = \
- $(AM_CPPFLAGS) \
- $(test_cflags)
+test_vt_CPPFLAGS = $(test_cflags)
test_vt_LDADD = \
$(test_libs) \
libuterm.la
test_input_SOURCES = \
$(test_sources) \
tests/test_input.c
-test_input_CPPFLAGS = \
- $(AM_CPPFLAGS) \
- $(test_cflags)
+test_input_CPPFLAGS = $(test_cflags)
test_input_LDADD = \
$(test_libs) \
libuterm.la
test_key_SOURCES = \
$(test_sources) \
tests/test_key.c
-test_key_CPPFLAGS = \
- $(AM_CPPFLAGS) \
- $(test_cflags)
-test_key_LDADD = \
- $(test_libs)
+test_key_CPPFLAGS = $(test_cflags)
+test_key_LDADD = $(test_libs)
#
# Manpages
AC_CONFIG_AUX_DIR([build-aux])
AC_CONFIG_MACRO_DIR([m4])
AC_CONFIG_HEADER(config.h)
+AC_USE_SYSTEM_EXTENSIONS
+AC_SYS_LARGEFILE
+AC_PREFIX_DEFAULT([/usr])
+AC_CANONICAL_HOST
AM_INIT_AUTOMAKE([foreign 1.11 subdir-objects dist-bzip2 no-dist-gzip tar-pax -Wall -Werror -Wno-portability])
AM_SILENT_RULES([yes])
: ${CFLAGS=""}
-AC_USE_SYSTEM_EXTENSIONS
AC_PROG_CC
AC_PROG_CC_C99
AM_PROG_CC_C_O
-AC_PROG_SED
m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
+AC_PROG_SED
+AC_PROG_MKDIR_P
+AC_PROG_LN_S
+AC_PROG_GREP
+AC_PROG_AWK
LT_PREREQ(2.2)
-LT_INIT
+LT_INIT([disable-static])
#
# pkg-config dependencies
--- /dev/null
+/***
+ * libeloop - Simple Event-Loop Library
+ *
+ * Copyright (c) 2012-2013 David Herrmann <dh.herrmann@googlemail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ***/
+
+LIBELOOP_1 {
+global:
+ ev_eloop_new;
+ ev_eloop_ref;
+ ev_eloop_unref;
+local:
+ *;
+};
+
+LIBELOOP_2 {
+global:
+ ev_eloop_flush_fd;
+ ev_eloop_dispatch;
+ ev_eloop_run;
+ ev_eloop_exit;
+ ev_eloop_get_fd;
+
+ ev_eloop_new_eloop;
+ ev_eloop_add_eloop;
+ ev_eloop_rm_eloop;
+
+ ev_fd_new;
+ ev_fd_ref;
+ ev_fd_unref;
+
+ ev_fd_enable;
+ ev_fd_disable;
+ ev_fd_is_enabled;
+ ev_fd_is_bound;
+ ev_fd_set_cb_data;
+ ev_fd_update;
+
+ ev_eloop_new_fd;
+ ev_eloop_add_fd;
+ ev_eloop_rm_fd;
+
+ ev_timer_new;
+ ev_timer_ref;
+ ev_timer_unref;
+
+ ev_timer_enable;
+ ev_timer_disable;
+ ev_timer_is_enabled;
+ ev_timer_is_bound;
+ ev_timer_set_cb_data;
+ ev_timer_update;
+ ev_timer_drain;
+
+ ev_eloop_new_timer;
+ ev_eloop_add_timer;
+ ev_eloop_rm_timer;
+
+ ev_counter_new;
+ ev_counter_ref;
+ ev_counter_unref;
+
+ ev_counter_enable;
+ ev_counter_disable;
+ ev_counter_is_enabled;
+ ev_counter_is_bound;
+ ev_counter_set_cb_data;
+ ev_counter_inc;
+
+ ev_eloop_new_counter;
+ ev_eloop_add_counter;
+ ev_eloop_rm_counter;
+
+ ev_eloop_register_signal_cb;
+ ev_eloop_unregister_signal_cb;
+
+ ev_eloop_register_child_cb;
+ ev_eloop_unregister_child_cb;
+
+ ev_eloop_register_idle_cb;
+ ev_eloop_unregister_idle_cb;
+
+ ev_eloop_register_pre_cb;
+ ev_eloop_unregister_pre_cb;
+
+ ev_eloop_register_post_cb;
+ ev_eloop_unregister_post_cb;
+} LIBELOOP_1;
--- /dev/null
+/***
+ * libtsm - Terminal-Emulator State Machine
+ *
+ * Copyright (c) 2012-2013 David Herrmann <dh.herrmann@googlemail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ***/
+
+LIBTSM_1 {
+global:
+ tsm_symbol_default;
+local:
+ *;
+};
+
+LIBTSM_2 {
+global:
+ tsm_symbol_table_new;
+ tsm_symbol_table_ref;
+ tsm_symbol_table_unref;
+
+ tsm_symbol_make;
+ tsm_symbol_append;
+ tsm_symbol_get;
+ tsm_symbol_get_width;
+
+ tsm_ucs4_get_width;
+ tsm_ucs4_to_utf8;
+ tsm_ucs4_to_utf8_alloc;
+
+ tsm_utf8_mach_new;
+ tsm_utf8_mach_free;
+
+ tsm_utf8_mach_feed;
+ tsm_utf8_mach_get;
+ tsm_utf8_mach_reset;
+
+ tsm_screen_new;
+ tsm_screen_ref;
+ tsm_screen_unref;
+
+ tsm_screen_set_opts;
+ tsm_screen_reset_opts;
+ tsm_screen_get_opts;
+
+ tsm_screen_get_width;
+ tsm_screen_get_height;
+ tsm_screen_resize;
+ tsm_screen_set_margins;
+ tsm_screen_set_max_sb;
+ tsm_screen_clear_sb;
+
+ tsm_screen_sb_up;
+ tsm_screen_sb_down;
+ tsm_screen_sb_page_up;
+ tsm_screen_sb_page_down;
+ tsm_screen_sb_reset;
+
+ tsm_screen_set_def_attr;
+ tsm_screen_reset;
+ tsm_screen_set_flags;
+ tsm_screen_reset_flags;
+ tsm_screen_get_flags;
+
+ tsm_screen_get_cursor_x;
+ tsm_screen_get_cursor_y;
+
+ tsm_screen_set_tabstop;
+ tsm_screen_reset_tabstop;
+ tsm_screen_reset_all_tabstops;
+
+ tsm_screen_write;
+ tsm_screen_newline;
+ tsm_screen_scroll_up;
+ tsm_screen_scroll_down;
+ tsm_screen_move_to;
+ tsm_screen_move_up;
+ tsm_screen_move_down;
+ tsm_screen_move_left;
+ tsm_screen_move_right;
+ tsm_screen_move_line_end;
+ tsm_screen_move_line_home;
+ tsm_screen_tab_right;
+ tsm_screen_tab_left;
+ tsm_screen_insert_lines;
+ tsm_screen_delete_lines;
+ tsm_screen_insert_chars;
+ tsm_screen_delete_chars;
+ tsm_screen_erase_cursor;
+ tsm_screen_erase_chars;
+ tsm_screen_erase_cursor_to_end;
+ tsm_screen_erase_home_to_cursor;
+ tsm_screen_erase_current_line;
+ tsm_screen_erase_screen_to_cursor;
+ tsm_screen_erase_cursor_to_screen;
+ tsm_screen_erase_screen;
+
+ tsm_screen_selection_reset;
+ tsm_screen_selection_start;
+ tsm_screen_selection_target;
+ tsm_screen_selection_copy;
+
+ tsm_screen_draw;
+
+ tsm_vte_unicode_lower;
+
+ tsm_vte_new;
+ tsm_vte_ref;
+ tsm_vte_unref;
+
+ tsm_vte_set_palette;
+
+ tsm_vte_reset;
+ tsm_vte_hard_reset;
+ tsm_vte_input;
+ tsm_vte_handle_keyboard;
+ tsm_vte_unicode_upper;
+ tsm_vte_dec_supplemental_graphics;
+ tsm_vte_dec_special_graphics;
+} LIBTSM_1;
--- /dev/null
+/***
+ * libuterm - User-Space Terminals
+ *
+ * Copyright (c) 2012-2013 David Herrmann <dh.herrmann@googlemail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ***/
+
+LIBUTERM_1 {
+global:
+ uterm_input_new;
+ uterm_input_ref;
+ uterm_input_unref;
+
+ uterm_input_add_dev;
+ uterm_input_remove_dev;
+
+ uterm_input_register_cb;
+ uterm_input_unregister_cb;
+
+ uterm_input_sleep;
+ uterm_input_wake_up;
+ uterm_input_is_awake;
+
+ uterm_vt_master_new;
+ uterm_vt_master_ref;
+ uterm_vt_master_unref;
+
+ uterm_vt_master_activate_all;
+ uterm_vt_master_deactivate_all;
+
+ uterm_vt_allocate;
+ uterm_vt_deallocate;
+ uterm_vt_ref;
+ uterm_vt_unref;
+
+ uterm_vt_activate;
+ uterm_vt_deactivate;
+ uterm_vt_retry;
+ uterm_vt_get_type;
+
+ uterm_dpms_to_name;
+ uterm_video_available;
+
+ uterm_mode_ref;
+ uterm_mode_unref;
+ uterm_mode_next;
+
+ uterm_mode_get_name;
+ uterm_mode_get_width;
+ uterm_mode_get_height;
+
+ uterm_display_ref;
+ uterm_display_unref;
+ uterm_display_next;
+
+ uterm_display_register_cb;
+ uterm_display_unregister_cb;
+
+ uterm_display_get_modes;
+ uterm_display_get_current;
+ uterm_display_get_default;
+
+ uterm_display_get_state;
+ uterm_display_activate;
+ uterm_display_deactivate;
+ uterm_display_set_dpms;
+ uterm_display_get_dpms;
+
+ uterm_display_use;
+ uterm_display_get_buffers;
+ uterm_display_swap;
+ uterm_display_is_swapping;
+
+ uterm_display_fill;
+ uterm_display_blit;
+ uterm_display_fake_blend;
+ uterm_display_fake_blendv;
+
+ uterm_video_new;
+ uterm_video_ref;
+ uterm_video_unref;
+
+ uterm_video_segfault;
+ uterm_video_get_displays;
+ uterm_video_register_cb;
+ uterm_video_unregister_cb;
+
+ uterm_video_sleep;
+ uterm_video_wake_up;
+ uterm_video_is_awake;
+ uterm_video_poll;
+
+ UTERM_VIDEO_FBDEV;
+ UTERM_VIDEO_DRM2D;
+ UTERM_VIDEO_DRM3D;
+
+ uterm_monitor_new;
+ uterm_monitor_ref;
+ uterm_monitor_unref;
+ uterm_monitor_scan;
+
+ uterm_monitor_set_seat_data;
+ uterm_monitor_set_dev_data;
+local:
+ *;
+};
#include "shl_dlist.h"
#include "shl_hook.h"
#include "shl_llog.h"
+#include "shl_misc.h"
#define LLOG_SUBSYSTEM "eloop"
*
* Returns: 0 on success, otherwise negative error code
*/
+SHL_EXPORT
int ev_eloop_new(struct ev_eloop **out, ev_log_t log)
{
struct ev_eloop *loop;
*
* This increases the ref-count of @loop by 1.
*/
+SHL_EXPORT
void ev_eloop_ref(struct ev_eloop *loop)
{
if (!loop)
* of the event loop so this ref-count will never drop to zero while there is an
* registered event source.
*/
+SHL_EXPORT
void ev_eloop_unref(struct ev_eloop *loop)
{
struct ev_signal_shared *sig;
* If @loop is currently dispatching events, this will remove all pending events
* of @fd from the current event-list.
*/
+SHL_EXPORT
void ev_eloop_flush_fd(struct ev_eloop *loop, struct ev_fd *fd)
{
int i;
*
* Returns: 0 on success, otherwise negative error code
*/
+SHL_EXPORT
int ev_eloop_dispatch(struct ev_eloop *loop, int timeout)
{
struct epoll_event *ep;
*
* Returns: 0 on success, otherwise a negative error code
*/
+SHL_EXPORT
int ev_eloop_run(struct ev_eloop *loop, int timeout)
{
int ret;
*
* This makes a call to ev_eloop_run() stop.
*/
+SHL_EXPORT
void ev_eloop_exit(struct ev_eloop *loop)
{
if (!loop)
*
* Returns: A file descriptor for the event loop or negative error code
*/
+SHL_EXPORT
int ev_eloop_get_fd(struct ev_eloop *loop)
{
if (!loop)
*
* Returns: 0 on success, otherwise negative error code
*/
+SHL_EXPORT
int ev_eloop_new_eloop(struct ev_eloop *loop, struct ev_eloop **out)
{
struct ev_eloop *el;
*
* Returns: 0 on success, otherwise negative error code
*/
+SHL_EXPORT
int ev_eloop_add_eloop(struct ev_eloop *loop, struct ev_eloop *add)
{
int ret;
* event loop was not registered on any other event loop, then this call does
* nothing.
*/
+SHL_EXPORT
void ev_eloop_rm_eloop(struct ev_eloop *rm)
{
if (!rm || !rm->fd->loop)
*
* Returns: 0 on success, otherwise negative error code
*/
+SHL_EXPORT
int ev_fd_new(struct ev_fd **out, int rfd, int mask, ev_fd_cb cb, void *data,
ev_log_t log)
{
*
* Increases the ref-count of @fd by 1.
*/
+SHL_EXPORT
void ev_fd_ref(struct ev_fd *fd)
{
if (!fd)
* Decreases the ref-count of @fd by 1. Destroys the object if the ref-count
* drops to zero.
*/
+SHL_EXPORT
void ev_fd_unref(struct ev_fd *fd)
{
if (!fd)
*
* Returns: 0 on success, otherwise negative error code
*/
+SHL_EXPORT
int ev_fd_enable(struct ev_fd *fd)
{
int ret;
* Disables @fd. That means, no more events are handled for @fd until you
* re-enable it with ev_fd_enable().
*/
+SHL_EXPORT
void ev_fd_disable(struct ev_fd *fd)
{
if (!fd || !fd->enabled)
*
* Returns: true if @fd is enabled, otherwise false.
*/
+SHL_EXPORT
bool ev_fd_is_enabled(struct ev_fd *fd)
{
return fd && fd->enabled;
*
* Returns: true if @fd is bound, otherwise false
*/
+SHL_EXPORT
bool ev_fd_is_bound(struct ev_fd *fd)
{
return fd && fd->loop;
* Both can be set to NULL. If @cb is NULL, then the callback will not be called
* anymore.
*/
+SHL_EXPORT
void ev_fd_set_cb_data(struct ev_fd *fd, ev_fd_cb cb, void *data)
{
if (!fd)
*
* Returns: 0 on success, otherwise negative error code
*/
+SHL_EXPORT
int ev_fd_update(struct ev_fd *fd, int mask)
{
int ret;
*
* Returns: 0 on success, otherwise negative error code
*/
+SHL_EXPORT
int ev_eloop_new_fd(struct ev_eloop *loop, struct ev_fd **out, int rfd,
int mask, ev_fd_cb cb, void *data)
{
*
* Returns: 0 on success, otherwise negative error code
*/
+SHL_EXPORT
int ev_eloop_add_fd(struct ev_eloop *loop, struct ev_fd *fd)
{
int ret;
* It is safe to call this in any callback. This makes sure that the current
* dispatcher will not get confused or read invalid memory.
*/
+SHL_EXPORT
void ev_eloop_rm_fd(struct ev_fd *fd)
{
struct ev_eloop *loop;
*
* Returns: 0 on success, negative error on failure
*/
+SHL_EXPORT
int ev_timer_new(struct ev_timer **out, const struct itimerspec *spec,
ev_timer_cb cb, void *data, ev_log_t log)
{
*
* Increase reference count by 1.
*/
+SHL_EXPORT
void ev_timer_ref(struct ev_timer *timer)
{
if (!timer)
*
* Decrease reference-count by 1 and destroy timer if it drops to 0.
*/
+SHL_EXPORT
void ev_timer_unref(struct ev_timer *timer)
{
if (!timer)
*
* Returns: 0 on success negative error code on failure
*/
+SHL_EXPORT
int ev_timer_enable(struct ev_timer *timer)
{
if (!timer)
*
* Returns: 0 on success and negative error code on failure
*/
+SHL_EXPORT
void ev_timer_disable(struct ev_timer *timer)
{
if (!timer)
*
* Returns: true if timer is enabled, false otherwise
*/
+SHL_EXPORT
bool ev_timer_is_enabled(struct ev_timer *timer)
{
return timer && ev_fd_is_enabled(timer->efd);
*
* Returns: true if the timer is bound, false otherwise.
*/
+SHL_EXPORT
bool ev_timer_is_bound(struct ev_timer *timer)
{
return timer && ev_fd_is_bound(timer->efd);
* This changes the user-supplied callback and data that is used for this timer
* object.
*/
+SHL_EXPORT
void ev_timer_set_cb_data(struct ev_timer *timer, ev_timer_cb cb, void *data)
{
if (!timer)
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_timer_update(struct ev_timer *timer, const struct itimerspec *spec)
{
int ret;
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_timer_drain(struct ev_timer *timer, uint64_t *expirations)
{
if (!timer)
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_eloop_new_timer(struct ev_eloop *loop, struct ev_timer **out,
const struct itimerspec *spec, ev_timer_cb cb,
void *data)
*
* Returns: 0 on success, negative error code on failure
*/
+SHL_EXPORT
int ev_eloop_add_timer(struct ev_eloop *loop, struct ev_timer *timer)
{
int ret;
* If @timer is currently bound to an event loop, this will remove this bondage
* again.
*/
+SHL_EXPORT
void ev_eloop_rm_timer(struct ev_timer *timer)
{
if (!timer || !ev_fd_is_bound(timer->efd))
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_counter_new(struct ev_counter **out, ev_counter_cb cb, void *data,
ev_log_t log)
{
*
* This increases the reference-count of @cnt by 1.
*/
+SHL_EXPORT
void ev_counter_ref(struct ev_counter *cnt)
{
if (!cnt)
* This decreases the reference-count of @cnt by 1 and destroys the object if
* it drops to 0.
*/
+SHL_EXPORT
void ev_counter_unref(struct ev_counter *cnt)
{
if (!cnt)
*
* Returns: 0 on success, negative error code on failure
*/
+SHL_EXPORT
int ev_counter_enable(struct ev_counter *cnt)
{
if (!cnt)
* This disables the counter. It calls ev_fd_disable() on the underlying
* file-descriptor.
*/
+SHL_EXPORT
void ev_counter_disable(struct ev_counter *cnt)
{
if (!cnt)
*
* Returns: true if the counter is enabled, otherwise returns false.
*/
+SHL_EXPORT
bool ev_counter_is_enabled(struct ev_counter *cnt)
{
return cnt && ev_fd_is_enabled(cnt->efd);
*
* Returns: true if the counter is bound, otherwise false is returned.
*/
+SHL_EXPORT
bool ev_counter_is_bound(struct ev_counter *cnt)
{
return cnt && ev_fd_is_bound(cnt->efd);
* This changes the user-supplied callback and data for the given counter
* object.
*/
+SHL_EXPORT
void ev_counter_set_cb_data(struct ev_counter *cnt, ev_counter_cb cb,
void *data)
{
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_counter_inc(struct ev_counter *cnt, uint64_t val)
{
if (!cnt)
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_eloop_new_counter(struct ev_eloop *eloop, struct ev_counter **out,
ev_counter_cb cb, void *data)
{
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_eloop_add_counter(struct ev_eloop *eloop, struct ev_counter *cnt)
{
int ret;
*
* If @cnt is bound to an event-loop, then this will remove this bondage again.
*/
+SHL_EXPORT
void ev_eloop_rm_counter(struct ev_counter *cnt)
{
if (!cnt || !ev_fd_is_bound(cnt->efd))
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_eloop_register_signal_cb(struct ev_eloop *loop, int signum,
ev_signal_shared_cb cb, void *data)
{
* callbacks with the same arguments are registered, then only one callback is
* removed. It doesn't matter which callback is removed as both are identical.
*/
+SHL_EXPORT
void ev_eloop_unregister_signal_cb(struct ev_eloop *loop, int signum,
ev_signal_shared_cb cb, void *data)
{
* the events while others will call waitpid() and get EAGAIN.
*/
+SHL_EXPORT
int ev_eloop_register_child_cb(struct ev_eloop *loop, ev_child_cb cb,
void *data)
{
return 0;
}
+SHL_EXPORT
void ev_eloop_unregister_child_cb(struct ev_eloop *loop, ev_child_cb cb,
void *data)
{
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_eloop_register_idle_cb(struct ev_eloop *eloop, ev_idle_cb cb,
void *data, unsigned int flags)
{
* then only one is removed. It doesn't matter which one is removed, because
* they are identical.
*/
+SHL_EXPORT
void ev_eloop_unregister_idle_cb(struct ev_eloop *eloop, ev_idle_cb cb,
void *data, unsigned int flags)
{
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_eloop_register_pre_cb(struct ev_eloop *eloop, ev_idle_cb cb,
void *data)
{
* then only one is removed. It doesn't matter which one is removed, because
* they are identical.
*/
+SHL_EXPORT
void ev_eloop_unregister_pre_cb(struct ev_eloop *eloop, ev_idle_cb cb,
void *data)
{
*
* Returns: 0 on success, negative error code on failure.
*/
+SHL_EXPORT
int ev_eloop_register_post_cb(struct ev_eloop *eloop, ev_idle_cb cb,
void *data)
{
* then only one is removed. It doesn't matter which one is removed, because
* they are identical.
*/
+SHL_EXPORT
void ev_eloop_unregister_post_cb(struct ev_eloop *eloop, ev_idle_cb cb,
void *data)
{
#include "kmscon_module.h"
#include "log.h"
#include "shl_dlist.h"
+#include "shl_misc.h"
#include "shl_register.h"
#define LOG_SUBSYSTEM "font"
* not set, then the height is calculated and after that the points are
* recalculated so we will never have division-errors.
*/
+SHL_EXPORT
void kmscon_font_attr_normalize(struct kmscon_font_attr *attr)
{
if (!attr)
*
* Returns: true if they match, otherwise false
*/
+SHL_EXPORT
bool kmscon_font_attr_match(const struct kmscon_font_attr *a1,
const struct kmscon_font_attr *a2)
{
*
* Returns: 0 on success, negative error code on failure
*/
+SHL_EXPORT
int kmscon_font_register(const struct kmscon_font_ops *ops)
{
int ret;
* This unregisters the font-backend that is registered with name @name. If
* @name is not found, a warning is printed but nothing else is done.
*/
+SHL_EXPORT
void kmscon_font_unregister(const char *name)
{
log_debug("unregister font backend %s", name);
*
* Returns: 0 on success, negative error code on failure
*/
+SHL_EXPORT
int kmscon_font_render(struct kmscon_font *font,
uint32_t id, const uint32_t *ch, size_t len,
const struct kmscon_glyph **out)
*
* Returns: 0 on success, negative error code on failure
*/
+SHL_EXPORT
int kmscon_font_render_empty(struct kmscon_font *font,
const struct kmscon_glyph **out)
{
*
* Returns: 0 on success ,engative error code on failure
*/
+SHL_EXPORT
int kmscon_font_render_inval(struct kmscon_font *font,
const struct kmscon_glyph **out)
{
#include "githead.h"
#include "kmscon_module.h"
#include "shl_dlist.h"
+#include "shl_misc.h"
struct kmscon_module_info {
const char *githead;
}, \
};
+SHL_EXPORT
extern struct kmscon_module module;
#define KMSCON_THIS_MODULE (&module)
#include <string.h>
#include "githead.h"
#include "log.h"
+#include "shl_misc.h"
/*
* Locking
* LOG_SUBSYSTEM: By default no subsystem is specified
*/
+SHL_EXPORT
const struct log_config LOG_CONFIG = {
.sev = {
[LOG_DEBUG] = 2,
va_end(list);
}
+SHL_EXPORT
void log_submit(const char *file,
int line,
const char *func,
errno = saved_errno;
}
+SHL_EXPORT
void log_format(const char *file,
int line,
const char *func,
errno = saved_errno;
}
+SHL_EXPORT
void log_llog(const char *file,
int line,
const char *func,
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
+#include <string.h>
#include <unistd.h>
#include <xkbcommon/xkbcommon.h>
+#define SHL_EXPORT __attribute__((visibility("default")))
#define SHL_HAS_BITS(_bitmask, _bits) (((_bitmask) & (_bits)) == (_bits))
#define SHL_DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
#include <string.h>
#include "log.h"
#include "shl_dlist.h"
+#include "shl_misc.h"
#include "shl_register.h"
#include "text.h"
#include "uterm_video.h"
*
* Returns: 0 on success, negative error code on failure
*/
+SHL_EXPORT
int kmscon_text_register(const struct kmscon_text_ops *ops)
{
int ret;
* This unregisters the text-backend that is registered with name @name. If
* @name is not found, nothing is done.
*/
+SHL_EXPORT
void kmscon_text_unregister(const char *name)
{
log_debug("unregister backend %s", name);
#include <stdlib.h>
#include <string.h>
#include "shl_llog.h"
+#include "shl_misc.h"
#include "shl_timer.h"
#include "tsm_screen.h"
#include "tsm_unicode.h"
return con->margin_top + y;
}
+SHL_EXPORT
int tsm_screen_new(struct tsm_screen **out, tsm_log_t log)
{
struct tsm_screen *con;
return ret;
}
+SHL_EXPORT
void tsm_screen_ref(struct tsm_screen *con)
{
if (!con)
++con->ref;
}
+SHL_EXPORT
void tsm_screen_unref(struct tsm_screen *con)
{
unsigned int i;
free(con);
}
+SHL_EXPORT
void tsm_screen_set_opts(struct tsm_screen *scr, unsigned int opts)
{
if (!scr || !opts)
scr->opts |= opts;
}
+SHL_EXPORT
void tsm_screen_reset_opts(struct tsm_screen *scr, unsigned int opts)
{
if (!scr || !opts)
scr->opts &= ~opts;
}
+SHL_EXPORT
unsigned int tsm_screen_get_opts(struct tsm_screen *scr)
{
if (!scr)
return scr->opts;
}
+SHL_EXPORT
unsigned int tsm_screen_get_width(struct tsm_screen *con)
{
if (!con)
return con->size_x;
}
+SHL_EXPORT
unsigned int tsm_screen_get_height(struct tsm_screen *con)
{
if (!con)
return con->size_y;
}
+SHL_EXPORT
int tsm_screen_resize(struct tsm_screen *con, unsigned int x,
unsigned int y)
{
return 0;
}
+SHL_EXPORT
int tsm_screen_set_margins(struct tsm_screen *con,
unsigned int top, unsigned int bottom)
{
}
/* set maximum scrollback buffer size */
+SHL_EXPORT
void tsm_screen_set_max_sb(struct tsm_screen *con,
unsigned int max)
{
}
/* clear scrollback buffer */
+SHL_EXPORT
void tsm_screen_clear_sb(struct tsm_screen *con)
{
struct line *iter, *tmp;
}
}
+SHL_EXPORT
void tsm_screen_sb_up(struct tsm_screen *con, unsigned int num)
{
if (!con || !num)
}
}
+SHL_EXPORT
void tsm_screen_sb_down(struct tsm_screen *con, unsigned int num)
{
if (!con || !num)
}
}
+SHL_EXPORT
void tsm_screen_sb_page_up(struct tsm_screen *con, unsigned int num)
{
if (!con || !num)
tsm_screen_sb_up(con, num * con->size_y);
}
+SHL_EXPORT
void tsm_screen_sb_page_down(struct tsm_screen *con, unsigned int num)
{
if (!con || !num)
tsm_screen_sb_down(con, num * con->size_y);
}
+SHL_EXPORT
void tsm_screen_sb_reset(struct tsm_screen *con)
{
if (!con)
con->sb_pos = NULL;
}
+SHL_EXPORT
void tsm_screen_set_def_attr(struct tsm_screen *con,
const struct tsm_screen_attr *attr)
{
memcpy(&con->def_attr, attr, sizeof(*attr));
}
+SHL_EXPORT
void tsm_screen_reset(struct tsm_screen *con)
{
unsigned int i;
}
}
+SHL_EXPORT
void tsm_screen_set_flags(struct tsm_screen *con, unsigned int flags)
{
unsigned int old;
con->lines = con->alt_lines;
}
+SHL_EXPORT
void tsm_screen_reset_flags(struct tsm_screen *con, unsigned int flags)
{
unsigned int old;
con->lines = con->main_lines;
}
+SHL_EXPORT
unsigned int tsm_screen_get_flags(struct tsm_screen *con)
{
if (!con)
return con->flags;
}
+SHL_EXPORT
unsigned int tsm_screen_get_cursor_x(struct tsm_screen *con)
{
if (!con)
return con->cursor_x;
}
+SHL_EXPORT
unsigned int tsm_screen_get_cursor_y(struct tsm_screen *con)
{
if (!con)
return con->cursor_y;
}
+SHL_EXPORT
void tsm_screen_set_tabstop(struct tsm_screen *con)
{
if (!con || con->cursor_x >= con->size_x)
con->tab_ruler[con->cursor_x] = true;
}
+SHL_EXPORT
void tsm_screen_reset_tabstop(struct tsm_screen *con)
{
if (!con || con->cursor_x >= con->size_x)
con->tab_ruler[con->cursor_x] = false;
}
+SHL_EXPORT
void tsm_screen_reset_all_tabstops(struct tsm_screen *con)
{
unsigned int i;
con->tab_ruler[i] = false;
}
+SHL_EXPORT
void tsm_screen_write(struct tsm_screen *con, tsm_symbol_t ch,
const struct tsm_screen_attr *attr)
{
con->cursor_x += len;
}
+SHL_EXPORT
void tsm_screen_newline(struct tsm_screen *con)
{
if (!con)
tsm_screen_move_line_home(con);
}
+SHL_EXPORT
void tsm_screen_scroll_up(struct tsm_screen *con, unsigned int num)
{
if (!con || !num)
screen_scroll_up(con, num);
}
+SHL_EXPORT
void tsm_screen_scroll_down(struct tsm_screen *con, unsigned int num)
{
if (!con || !num)
screen_scroll_down(con, num);
}
+SHL_EXPORT
void tsm_screen_move_to(struct tsm_screen *con, unsigned int x,
unsigned int y)
{
con->cursor_y = last;
}
+SHL_EXPORT
void tsm_screen_move_up(struct tsm_screen *con, unsigned int num,
bool scroll)
{
}
}
+SHL_EXPORT
void tsm_screen_move_down(struct tsm_screen *con, unsigned int num,
bool scroll)
{
}
}
+SHL_EXPORT
void tsm_screen_move_left(struct tsm_screen *con, unsigned int num)
{
if (!con || !num)
con->cursor_x -= num;
}
+SHL_EXPORT
void tsm_screen_move_right(struct tsm_screen *con, unsigned int num)
{
if (!con || !num)
con->cursor_x += num;
}
+SHL_EXPORT
void tsm_screen_move_line_end(struct tsm_screen *con)
{
if (!con)
con->cursor_x = con->size_x - 1;
}
+SHL_EXPORT
void tsm_screen_move_line_home(struct tsm_screen *con)
{
if (!con)
con->cursor_x = 0;
}
+SHL_EXPORT
void tsm_screen_tab_right(struct tsm_screen *con, unsigned int num)
{
unsigned int i, j;
con->cursor_x = con->size_x - 1;
}
+SHL_EXPORT
void tsm_screen_tab_left(struct tsm_screen *con, unsigned int num)
{
unsigned int i;
}
}
+SHL_EXPORT
void tsm_screen_insert_lines(struct tsm_screen *con, unsigned int num)
{
unsigned int i, j, max;
con->cursor_x = 0;
}
+SHL_EXPORT
void tsm_screen_delete_lines(struct tsm_screen *con, unsigned int num)
{
unsigned int i, j, max;
con->cursor_x = 0;
}
+SHL_EXPORT
void tsm_screen_insert_chars(struct tsm_screen *con, unsigned int num)
{
struct cell *cells;
}
}
+SHL_EXPORT
void tsm_screen_delete_chars(struct tsm_screen *con, unsigned int num)
{
struct cell *cells;
}
}
+SHL_EXPORT
void tsm_screen_erase_cursor(struct tsm_screen *con)
{
unsigned int x;
screen_erase_region(con, x, con->cursor_y, x, con->cursor_y, false);
}
+SHL_EXPORT
void tsm_screen_erase_chars(struct tsm_screen *con, unsigned int num)
{
unsigned int x;
false);
}
+SHL_EXPORT
void tsm_screen_erase_cursor_to_end(struct tsm_screen *con,
bool protect)
{
con->cursor_y, protect);
}
+SHL_EXPORT
void tsm_screen_erase_home_to_cursor(struct tsm_screen *con,
bool protect)
{
con->cursor_y, protect);
}
+SHL_EXPORT
void tsm_screen_erase_current_line(struct tsm_screen *con,
bool protect)
{
con->cursor_y, protect);
}
+SHL_EXPORT
void tsm_screen_erase_screen_to_cursor(struct tsm_screen *con,
bool protect)
{
screen_erase_region(con, 0, 0, con->cursor_x, con->cursor_y, protect);
}
+SHL_EXPORT
void tsm_screen_erase_cursor_to_screen(struct tsm_screen *con,
bool protect)
{
con->size_y - 1, protect);
}
+SHL_EXPORT
void tsm_screen_erase_screen(struct tsm_screen *con, bool protect)
{
if (!con)
sel->y = y;
}
+SHL_EXPORT
void tsm_screen_selection_reset(struct tsm_screen *con)
{
if (!con)
con->sel_active = false;
}
+SHL_EXPORT
void tsm_screen_selection_start(struct tsm_screen *con,
unsigned int posx,
unsigned int posy)
memcpy(&con->sel_end, &con->sel_start, sizeof(con->sel_end));
}
+SHL_EXPORT
void tsm_screen_selection_target(struct tsm_screen *con,
unsigned int posx,
unsigned int posy)
/* TODO: This beast definitely needs some "beautification", however, it's meant
* as a "proof-of-concept" so its enough for now. */
+SHL_EXPORT
int tsm_screen_selection_copy(struct tsm_screen *con, char **out)
{
unsigned int len, i;
return pos - str;
}
+SHL_EXPORT
void tsm_screen_draw(struct tsm_screen *con,
tsm_screen_prepare_cb prepare_cb,
tsm_screen_draw_cb draw_cb,
#include "external/wcwidth.h"
#include "shl_array.h"
#include "shl_hashtable.h"
+#include "shl_misc.h"
#include "tsm_unicode.h"
/*
* push the new symbol into the symbol table.
*/
+SHL_EXPORT
const tsm_symbol_t tsm_symbol_default = 0;
struct tsm_symbol_table {
}
}
+SHL_EXPORT
int tsm_symbol_table_new(struct tsm_symbol_table **out)
{
struct tsm_symbol_table *tbl;
return ret;
}
+SHL_EXPORT
void tsm_symbol_table_ref(struct tsm_symbol_table *tbl)
{
if (!tbl || !tbl->ref)
++tbl->ref;
}
+SHL_EXPORT
void tsm_symbol_table_unref(struct tsm_symbol_table *tbl)
{
if (!tbl || !tbl->ref || --tbl->ref)
free(tbl);
}
+SHL_EXPORT
tsm_symbol_t tsm_symbol_make(uint32_t ucs4)
{
if (ucs4 > TSM_UCS4_MAX)
* This always returns a valid value. If an error happens, the default character
* is returned. If \size is NULL, then the size value is omitted.
*/
+SHL_EXPORT
const uint32_t *tsm_symbol_get(struct tsm_symbol_table *tbl,
tsm_symbol_t *sym, size_t *size)
{
return ucs4;
}
+SHL_EXPORT
tsm_symbol_t tsm_symbol_append(struct tsm_symbol_table *tbl,
tsm_symbol_t sym, uint32_t ucs4)
{
return sym;
}
+SHL_EXPORT
unsigned int tsm_symbol_get_width(struct tsm_symbol_table *tbl,
tsm_symbol_t sym)
{
* 0xFFFF or 0xFFFE.
*/
+SHL_EXPORT
unsigned int tsm_ucs4_get_width(uint32_t ucs4)
{
int ret;
return ret;
}
+SHL_EXPORT
size_t tsm_ucs4_to_utf8(uint32_t g, char *txt)
{
if (g >= 0xd800 && g <= 0xdfff)
}
}
+SHL_EXPORT
char *tsm_ucs4_to_utf8_alloc(const uint32_t *ucs4, size_t len, size_t *len_out)
{
char *val;
uint32_t ch;
};
+SHL_EXPORT
int tsm_utf8_mach_new(struct tsm_utf8_mach **out)
{
struct tsm_utf8_mach *mach;
return 0;
}
+SHL_EXPORT
void tsm_utf8_mach_free(struct tsm_utf8_mach *mach)
{
if (!mach)
free(mach);
}
+SHL_EXPORT
int tsm_utf8_mach_feed(struct tsm_utf8_mach *mach, char ci)
{
uint32_t c;
return mach->state;
}
+SHL_EXPORT
uint32_t tsm_utf8_mach_get(struct tsm_utf8_mach *mach)
{
if (!mach || mach->state != TSM_UTF8_ACCEPT)
return mach->ch;
}
+SHL_EXPORT
void tsm_utf8_mach_reset(struct tsm_utf8_mach *mach)
{
if (!mach)
#include <string.h>
#include <xkbcommon/xkbcommon-keysyms.h>
#include "shl_llog.h"
+#include "shl_misc.h"
#include "tsm_screen.h"
#include "tsm_unicode.h"
#include "tsm_vte.h"
dest->bb = src->bb;
}
+SHL_EXPORT
int tsm_vte_new(struct tsm_vte **out, struct tsm_screen *con,
tsm_vte_write_cb write_cb, void *data,
tsm_log_t log)
return ret;
}
+SHL_EXPORT
void tsm_vte_ref(struct tsm_vte *vte)
{
if (!vte)
vte->ref++;
}
+SHL_EXPORT
void tsm_vte_unref(struct tsm_vte *vte)
{
if (!vte || !vte->ref)
free(vte);
}
+SHL_EXPORT
int tsm_vte_set_palette(struct tsm_vte *vte, const char *palette)
{
char *tmp = NULL;
* same state as when the VTE was created. This does not affect the console,
* though.
*/
+SHL_EXPORT
void tsm_vte_reset(struct tsm_vte *vte)
{
if (!vte)
reset_state(vte);
}
+SHL_EXPORT
void tsm_vte_hard_reset(struct tsm_vte *vte)
{
tsm_vte_reset(vte);
llog_warn(vte, "unhandled input %u in state %d", raw, vte->state);
}
+SHL_EXPORT
void tsm_vte_input(struct tsm_vte *vte, const char *u8, size_t len)
{
int state;
--vte->parse_cnt;
}
+SHL_EXPORT
bool tsm_vte_handle_keyboard(struct tsm_vte *vte, uint32_t keysym,
uint32_t ascii, unsigned int mods,
uint32_t unicode)
#include <errno.h>
#include <stdlib.h>
#include <string.h>
+#include "shl_misc.h"
#include "tsm_vte.h"
/*
* characters 33-126. These are all graphics characters defined in ASCII. The
* first an last entry are never used so we can safely set them to anything.
*/
+SHL_EXPORT
tsm_vte_charset tsm_vte_unicode_lower = {
[0] = 0,
[1] = 33,
* for the definitions of each symbol. Again, the first an last entry are never
* used so set them to 0.
*/
+SHL_EXPORT
tsm_vte_charset tsm_vte_unicode_upper = {
[0] = 0,
[1] = 161,
* This is very similar to unicode_upper, however, few symbols differ so do not
* mix them up!
*/
+SHL_EXPORT
tsm_vte_charset tsm_vte_dec_supplemental_graphics = {
[0] = 0,
[1] = 161,
* commonly used for ASCII drawings. It depends on the Unicode Standard 3.2 for
* the extended horizontal scan-line characters 3, 5, 7, and 9.
*/
+SHL_EXPORT
tsm_vte_charset tsm_vte_dec_special_graphics = {
[0] = 0,
[1] = 33,
#include <xf86drmMode.h>
#include "eloop.h"
#include "log.h"
+#include "shl_misc.h"
#include "uterm_drm_shared_internal.h"
#include "uterm_drm2d_internal.h"
#include "uterm_video.h"
.ops = &drm2d_video_ops,
};
+SHL_EXPORT
const struct uterm_video_module *UTERM_VIDEO_DRM2D = &drm2d_module;
#include <xf86drmMode.h>
#include "eloop.h"
#include "log.h"
+#include "shl_misc.h"
#include "static_gl.h"
#include "uterm_drm_shared_internal.h"
#include "uterm_drm3d_internal.h"
.ops = &drm_video_ops,
};
+SHL_EXPORT
const struct uterm_video_module *UTERM_VIDEO_DRM3D = &drm3d_module;
#include <sys/mman.h>
#include <unistd.h>
#include "log.h"
+#include "shl_misc.h"
#include "uterm_fbdev_internal.h"
#include "uterm_video.h"
#include "uterm_video_internal.h"
.ops = &fbdev_video_ops,
};
+SHL_EXPORT
const struct uterm_video_module *UTERM_VIDEO_FBDEV = &fbdev_module;
#include "log.h"
#include "shl_dlist.h"
#include "shl_hook.h"
+#include "shl_misc.h"
#include "uterm_input.h"
#include "uterm_input_internal.h"
free(dev);
}
+SHL_EXPORT
int uterm_input_new(struct uterm_input **out,
struct ev_eloop *eloop,
const char *model,
return ret;
}
+SHL_EXPORT
void uterm_input_ref(struct uterm_input *input)
{
if (!input || !input->ref)
++input->ref;
}
+SHL_EXPORT
void uterm_input_unref(struct uterm_input *input)
{
struct uterm_input_dev *dev;
return 0;
}
+SHL_EXPORT
void uterm_input_add_dev(struct uterm_input *input, const char *node)
{
unsigned int capabilities;
input_new_dev(input, node, capabilities);
}
+SHL_EXPORT
void uterm_input_remove_dev(struct uterm_input *input, const char *node)
{
struct shl_dlist *iter;
}
}
+SHL_EXPORT
int uterm_input_register_cb(struct uterm_input *input,
uterm_input_cb cb,
void *data)
return shl_hook_add_cast(input->hook, cb, data, false);
}
+SHL_EXPORT
void uterm_input_unregister_cb(struct uterm_input *input,
uterm_input_cb cb,
void *data)
shl_hook_rm_cast(input->hook, cb, data);
}
+SHL_EXPORT
void uterm_input_sleep(struct uterm_input *input)
{
struct shl_dlist *iter;
}
}
+SHL_EXPORT
void uterm_input_wake_up(struct uterm_input *input)
{
struct shl_dlist *iter, *tmp;
}
}
+SHL_EXPORT
bool uterm_input_is_awake(struct uterm_input *input)
{
if (!input)
#include <unistd.h>
#include "log.h"
#include "shl_dlist.h"
+#include "shl_misc.h"
#include "uterm_monitor.h"
#include "uterm_systemd_internal.h"
}
}
+SHL_EXPORT
int uterm_monitor_new(struct uterm_monitor **out,
struct ev_eloop *eloop,
uterm_monitor_cb cb,
return ret;
}
+SHL_EXPORT
void uterm_monitor_ref(struct uterm_monitor *mon)
{
if (!mon || !mon->ref)
++mon->ref;
}
+SHL_EXPORT
void uterm_monitor_unref(struct uterm_monitor *mon)
{
struct uterm_monitor_seat *seat;
free(mon);
}
+SHL_EXPORT
void uterm_monitor_scan(struct uterm_monitor *mon)
{
struct udev_enumerate *e;
udev_enumerate_unref(e);
}
+SHL_EXPORT
void uterm_monitor_set_seat_data(struct uterm_monitor_seat *seat, void *data)
{
if (!seat)
seat->data = data;
}
+SHL_EXPORT
void uterm_monitor_set_dev_data(struct uterm_monitor_dev *dev, void *data)
{
if (!dev)
#include "log.h"
#include "shl_dlist.h"
#include "shl_hook.h"
+#include "shl_misc.h"
#include "uterm_video.h"
#include "uterm_video_internal.h"
#define LOG_SUBSYSTEM "video"
+SHL_EXPORT
const char *uterm_dpms_to_name(int dpms)
{
switch (dpms) {
}
}
+SHL_EXPORT
bool uterm_video_available(const struct uterm_video_module *mod)
{
if (!mod)
return true;
}
+SHL_EXPORT
int mode_new(struct uterm_mode **out, const struct mode_ops *ops)
{
struct uterm_mode *mode;
return ret;
}
+SHL_EXPORT
void uterm_mode_ref(struct uterm_mode *mode)
{
if (!mode || !mode->ref)
++mode->ref;
}
+SHL_EXPORT
void uterm_mode_unref(struct uterm_mode *mode)
{
if (!mode || !mode->ref || --mode->ref)
free(mode);
}
+SHL_EXPORT
int uterm_mode_bind(struct uterm_mode *mode, struct uterm_display *disp)
{
if (!mode || !disp || mode->disp)
return 0;
}
+SHL_EXPORT
void uterm_mode_unbind(struct uterm_mode *mode)
{
if (!mode)
uterm_mode_unref(mode);
}
+SHL_EXPORT
struct uterm_mode *uterm_mode_next(struct uterm_mode *mode)
{
if (!mode || mode->list.next == &mode->disp->modes)
return shl_dlist_entry(mode->list.next, struct uterm_mode, list);
}
+SHL_EXPORT
const char *uterm_mode_get_name(const struct uterm_mode *mode)
{
if (!mode)
return VIDEO_CALL(mode->ops->get_name, NULL, mode);
}
+SHL_EXPORT
unsigned int uterm_mode_get_width(const struct uterm_mode *mode)
{
if (!mode)
return VIDEO_CALL(mode->ops->get_width, 0, mode);
}
+SHL_EXPORT
unsigned int uterm_mode_get_height(const struct uterm_mode *mode)
{
if (!mode)
return ret;
}
+SHL_EXPORT
void uterm_display_ref(struct uterm_display *disp)
{
if (!disp || !disp->ref)
++disp->ref;
}
+SHL_EXPORT
void uterm_display_unref(struct uterm_display *disp)
{
struct uterm_mode *mode;
free(disp);
}
+SHL_EXPORT
int uterm_display_bind(struct uterm_display *disp, struct uterm_video *video)
{
int ret;
return 0;
}
+SHL_EXPORT
void uterm_display_unbind(struct uterm_display *disp)
{
if (!disp || !disp->video)
uterm_display_unref(disp);
}
+SHL_EXPORT
struct uterm_display *uterm_display_next(struct uterm_display *disp)
{
if (!disp || !disp->video || disp->list.next == &disp->video->displays)
return shl_dlist_entry(disp->list.next, struct uterm_display, list);
}
+SHL_EXPORT
int uterm_display_register_cb(struct uterm_display *disp, uterm_display_cb cb,
void *data)
{
return shl_hook_add_cast(disp->hook, cb, data, false);
}
+SHL_EXPORT
void uterm_display_unregister_cb(struct uterm_display *disp,
uterm_display_cb cb, void *data)
{
shl_hook_rm_cast(disp->hook, cb, data);
}
+SHL_EXPORT
struct uterm_mode *uterm_display_get_modes(struct uterm_display *disp)
{
if (!disp || shl_dlist_empty(&disp->modes))
return shl_dlist_entry(disp->modes.next, struct uterm_mode, list);
}
+SHL_EXPORT
struct uterm_mode *uterm_display_get_current(struct uterm_display *disp)
{
if (!disp)
return disp->current_mode;
}
+SHL_EXPORT
struct uterm_mode *uterm_display_get_default(struct uterm_display *disp)
{
if (!disp)
return disp->default_mode;
}
+SHL_EXPORT
int uterm_display_get_state(struct uterm_display *disp)
{
if (!disp)
}
}
+SHL_EXPORT
int uterm_display_activate(struct uterm_display *disp, struct uterm_mode *mode)
{
if (!disp || !disp->video || display_is_online(disp) ||
return VIDEO_CALL(disp->ops->activate, 0, disp, mode);
}
+SHL_EXPORT
void uterm_display_deactivate(struct uterm_display *disp)
{
if (!disp || !display_is_online(disp))
VIDEO_CALL(disp->ops->deactivate, 0, disp);
}
+SHL_EXPORT
int uterm_display_set_dpms(struct uterm_display *disp, int state)
{
if (!disp || !display_is_online(disp) || !video_is_awake(disp->video))
return VIDEO_CALL(disp->ops->set_dpms, 0, disp, state);
}
+SHL_EXPORT
int uterm_display_get_dpms(const struct uterm_display *disp)
{
if (!disp || !disp->video)
return disp->dpms;
}
+SHL_EXPORT
int uterm_display_use(struct uterm_display *disp, bool *opengl)
{
if (!disp || !display_is_online(disp))
return VIDEO_CALL(disp->ops->use, -EOPNOTSUPP, disp, opengl);
}
+SHL_EXPORT
int uterm_display_get_buffers(struct uterm_display *disp,
struct uterm_video_buffer *buffer,
unsigned int formats)
formats);
}
+SHL_EXPORT
int uterm_display_swap(struct uterm_display *disp, bool immediate)
{
if (!disp || !display_is_online(disp) || !video_is_awake(disp->video))
return VIDEO_CALL(disp->ops->swap, 0, disp, immediate);
}
+SHL_EXPORT
bool uterm_display_is_swapping(struct uterm_display *disp)
{
if (!disp)
return disp->vblank_scheduled || (disp->flags & DISPLAY_VSYNC);
}
+SHL_EXPORT
int uterm_display_fill(struct uterm_display *disp,
uint8_t r, uint8_t g, uint8_t b,
unsigned int x, unsigned int y,
width, height);
}
+SHL_EXPORT
int uterm_display_blit(struct uterm_display *disp,
const struct uterm_video_buffer *buf,
unsigned int x, unsigned int y)
return VIDEO_CALL(disp->ops->blit, -EOPNOTSUPP, disp, buf, x, y);
}
+SHL_EXPORT
int uterm_display_fake_blend(struct uterm_display *disp,
const struct uterm_video_buffer *buf,
unsigned int x, unsigned int y,
return VIDEO_CALL(disp->ops->fake_blendv, -EOPNOTSUPP, disp, &req, 1);
}
+SHL_EXPORT
int uterm_display_fake_blendv(struct uterm_display *disp,
const struct uterm_video_blend_req *req,
size_t num)
return VIDEO_CALL(disp->ops->fake_blendv, -EOPNOTSUPP, disp, req, num);
}
+SHL_EXPORT
int uterm_video_new(struct uterm_video **out, struct ev_eloop *eloop,
const char *node, const struct uterm_video_module *mod)
{
return ret;
}
+SHL_EXPORT
void uterm_video_ref(struct uterm_video *video)
{
if (!video || !video->ref)
++video->ref;
}
+SHL_EXPORT
void uterm_video_unref(struct uterm_video *video)
{
struct uterm_display *disp;
free(video);
}
+SHL_EXPORT
void uterm_video_segfault(struct uterm_video *video)
{
if (!video)
VIDEO_CALL(video->ops->segfault, 0, video);
}
+SHL_EXPORT
struct uterm_display *uterm_video_get_displays(struct uterm_video *video)
{
if (!video || shl_dlist_empty(&video->displays))
list);
}
+SHL_EXPORT
int uterm_video_register_cb(struct uterm_video *video, uterm_video_cb cb,
void *data)
{
return shl_hook_add_cast(video->hook, cb, data, false);
}
+SHL_EXPORT
void uterm_video_unregister_cb(struct uterm_video *video, uterm_video_cb cb,
void *data)
{
shl_hook_rm_cast(video->hook, cb, data);
}
+SHL_EXPORT
void uterm_video_sleep(struct uterm_video *video)
{
if (!video || !video_is_awake(video))
VIDEO_CALL(video->ops->sleep, 0, video);
}
+SHL_EXPORT
int uterm_video_wake_up(struct uterm_video *video)
{
int ret;
return 0;
}
+SHL_EXPORT
bool uterm_video_is_awake(struct uterm_video *video)
{
return video && video_is_awake(video);
}
+SHL_EXPORT
void uterm_video_poll(struct uterm_video *video)
{
if (!video)
return 0;
}
+SHL_EXPORT
int uterm_vt_allocate(struct uterm_vt_master *vtm,
struct uterm_vt **out,
unsigned int allowed_types,
return ret;
}
+SHL_EXPORT
void uterm_vt_deallocate(struct uterm_vt *vt)
{
if (!vt || !vt->vtm)
uterm_vt_unref(vt);
}
+SHL_EXPORT
void uterm_vt_ref(struct uterm_vt *vt)
{
if (!vt || !vt->ref)
++vt->ref;
}
+SHL_EXPORT
void uterm_vt_unref(struct uterm_vt *vt)
{
if (!vt || !vt->ref || --vt->ref)
free(vt);
}
+SHL_EXPORT
int uterm_vt_activate(struct uterm_vt *vt)
{
if (!vt || !vt->vtm)
return fake_activate(vt);
}
+SHL_EXPORT
int uterm_vt_deactivate(struct uterm_vt *vt)
{
if (!vt || !vt->vtm)
return fake_deactivate(vt);
}
+SHL_EXPORT
void uterm_vt_retry(struct uterm_vt *vt)
{
if (!vt || !vt->vtm)
real_retry(vt);
}
+SHL_EXPORT
unsigned int uterm_vt_get_type(struct uterm_vt *vt)
{
if (!vt)
return vt->mode;
}
+SHL_EXPORT
int uterm_vt_master_new(struct uterm_vt_master **out,
struct ev_eloop *eloop)
{
return 0;
}
+SHL_EXPORT
void uterm_vt_master_ref(struct uterm_vt_master *vtm)
{
if (!vtm || !vtm->ref)
/* Drops a reference to the VT-master. If the reference drops to 0, all
* allocated VTs are deallocated and the VT-master is destroyed. */
+SHL_EXPORT
void uterm_vt_master_unref(struct uterm_vt_master *vtm)
{
struct uterm_vt *vt;
/* Calls uterm_vt_activate() on all allocated VTs on this master. Returns
* number of VTs that returned -EINPROGRESS or a negative error code on failure.
* See uterm_vt_activate() for information. */
+SHL_EXPORT
int uterm_vt_master_activate_all(struct uterm_vt_master *vtm)
{
struct uterm_vt *vt;
/* Calls uterm_vt_deactivate() on all allocated VTs on this master. Returns
* number of VTs that returned -EINPROGRESS or a negative error code on failure.
* See uterm_vt_deactivate() for information. */
+SHL_EXPORT
int uterm_vt_master_deactivate_all(struct uterm_vt_master *vtm)
{
struct uterm_vt *vt;
projects / platform / upstream / kmscon.git / commitdiff