Provided via github. Fixes typos in documentation and comments.
Signed-off-by: David Herrmann <dh.herrmann@googlemail.com>
* Idle sources are now faster registered and unregistered so they can
be used for any scheduling tasks
- * eloop got pre- and post-dispatch hooks to inetgrate external
+ * eloop got pre- and post-dispatch hooks to integrate external
event-loops better
* Added pkg-config files for eloop, tsm and uterm
CHANGES WITH 1: (development release)
* First kmscon release. For testing purposes only. Includes a rendering
- pipeline and a very rundimentary terminal emulator.
+ pipeline and a very rudimentary terminal emulator.
#
# Don't add a default "-g -O2" if CFLAGS wasn't specified. For debugging it is
# often more convenient to have "-g -O0". You can still override it by
-# explicitely setting it on the command line.
+# explicitly setting it on the command line.
#
: ${CFLAGS=""}
#
# Miscellaneous Checks
# All checks below are independent of module checking or depend on the results
-# of it. They do not have any dependencies themself so they are not part of the
+# of it. They do not have any dependencies themselves so they are not part of the
# module infrastructure.
#
disable a shortcut, pass an empty argument (empty list). A keyboard
shortcut exists of a list of modifiers followed by a single key. All
modifiers must be down when the key is pressed for the shortcut to be
- detected. A modifier is sorrounded by '<' and '>' (like
+ detected. A modifier is surrounded by '<' and '>' (like
'<shift>'). A key is the name of a keysym (like 'a' or
'Return'). Keysyms are case-sensitive and kmscon will suggest a keysym
name if you entered a wrong case. However, kmscon can not always guess
<para>Switching VTs is done by signaling the active process to go asleep and
signaling the new VT to wake up. If kmscon emulates VTs, it needs to
be able to send these signals to the processes running on fake VTs. In
- most situations this means kmscon must have root priviledges.</para>
+ most situations this means kmscon must have root privileges.</para>
</refsect1>
<refsect1>
+ * is, blanking the screen when the fb driver failed to perform
+ * an fb_blank(). It simply writes empty lines to the screen.
+ * We are not interested in this signal. We should also never
-+ * run together with fbcon so this should never be catched. */
++ * run together with fbcon so this should never be caught. */
+ /* ignore */
+ break;
+ case FB_EVENT_GET_CONSOLE_MAP:
* When an event occurs, the user-supplied callback is called.
*
* The event-loop allows the callbacks to modify _any_ data they want. They can
- * remove themself or other sources from the event loop even in a callback.
+ * remove themselves or other sources from the event loop even in a callback.
* This, however, means that recursive dispatch calls are not supported to
* increase performance and avoid internal dispatch-stacks.
*
* A source can be registered for a single event-loop only! You cannot add it
* to multiple event loops simultaneously. Also all provided sources are based
* on the file-descriptor source so it is guaranteed that you can get a
- * file-desciptor for every source-type. This is not exported via the public
+ * file-descriptor for every source-type. This is not exported via the public
* API, but you can get the epoll-fd which is basically a selectable FD summary
* of all event sources.
*
* However, the library does not enforce this design-choice. On the contrary,
* it supports all other types of application-designs, too. But as it is
* optimized for performance, other application-designs may need to add further
- * functionality (like thread-affinity) by themself as it would slow down the
+ * functionality (like thread-affinity) by themselves as it would slow down the
* event loop if it was natively implemented.
*
*
* signal). This is done internally by sharing the signalfd.
* However, there is one restriction: You cannot share a signalfd between
* multiple eloop-instances. That is, if you register a callback for the same
- * signal on two different eloop-instances (which are connected themself),
+ * signal on two different eloop-instances (which are connected themselves),
* then only one eloop-instance will fire the signal source. This is a
* restriction of signalfd that cannot be overcome. However, it is very
* uncommon to register multiple callbacks for a signal so this shouldn't
* @ref: refcnt for object
* @llog: llog log function
* @llog_data: llog log function user-data
- * @fd: the actual file desciptor
- * @mask: the event mask for this fd (EV_READABLE, EV_WRITABLE, ...)
+ * @fd: the actual file descriptor
+ * @mask: the event mask for this fd (EV_READABLE, EV_WRITEABLE, ...)
* @cb: the user callback
* @data: the user data
* @enabled: true if the object is currently enabled
* @llog_data: llog log function user-data
* @cb: user callback
* @data: user data
- * @fd: the timerfd file desciptor
+ * @fd: the timerfd file descriptor
* @efd: fd-source for @fd
*
* Based on timerfd this allows firing events based on relative timeouts.
* @llog_data: llog log function user-data
* @cb: user callback
* @data: user data
- * @fd: eventfd file desciptor
+ * @fd: eventfd file descriptor
* @efd: fd-source for @fd
*
* Counter sources fire if they are non-zero. They are based on the eventfd
/**
* ev_signal_shared:
* @list: list integration into ev_eloop object
- * @fd: the signalfd file desciptor for this signal
+ * @fd: the signalfd file descriptor for this signal
* @signum: the actual signal number
* @hook: list of registered user callbacks for this signal
*
* A shared signal allows multiple listeners for the same signal. All listeners
- * are called if the signal is catched.
+ * are called if the signal is caught.
*/
struct ev_signal_shared {
struct shl_dlist list;
* That means, the user can register for a signal and if no other user is
* registered for this signal, yet, we create a new shared signal. Otherwise,
* we add the user to the existing shared signals.
- * If the signal is catched, we simply call all users that are registered for
+ * If the signal is caught, we simply call all users that are registered for
* this signal.
* To avoid side-effects, we automatically block all signals for the current
* thread when a signalfd is created. We never unblock the signal. However,
* @timeout: Timeout in milliseconds
*
* This listens on @loop for incoming events and handles all events that
- * occured. This waits at most @timeout milliseconds until returning. If
+ * occurred. This waits at most @timeout milliseconds until returning. If
* @timeout is -1, this waits until the first event arrives. If @timeout is 0,
* then this returns directly if no event is currently pending.
*
* @loop: The parent event-loop where the new event loop is registered
* @out: Storage for new event loop
*
- * This creates a new event loop and directly registeres it as event source on
+ * This creates a new event loop and directly registers it as event source on
* the parent event loop \loop.
*
* Returns: 0 on success, otherwise negative error code
/**
* ev_fd_new:
* @out: Storage for result
- * @rfd: The actual file desciptor
- * @mask: Bitmask of %EV_READABLE and %EV_WRITeABLE flags
+ * @rfd: The actual file descriptor
+ * @mask: Bitmask of %EV_READABLE and %EV_WRITEABLE flags
* @cb: User callback
* @data: User data
* @log: llog function or NULL
* @log_data: logging function user-data
*
- * This creates a new file desciptor source that is watched for the events set
+ * This creates a new file descriptor source that is watched for the events set
* in @mask. @rfd is the system filedescriptor. The resulting object is stored
* in @out. @cb and @data are the user callback and the user-supplied data that
* is passed to the callback on events.
/*
* Idle sources
- * Idle sources are called everytime when a next dispatch round is started.
+ * Idle sources are called every time when a next dispatch round is started.
* That means, unless there is no idle source registered, the thread will
* _never_ go to sleep. So please unregister your idle source if no longer
* needed.
* Pre-Dispatch Callbacks
* A pre-dispatch cb is called before a single dispatch round is started.
* You should avoid using them and instead not rely on any specific
- * dispatch-behavior but expect every event to be recieved asynchronously.
+ * dispatch-behavior but expect every event to be received asynchronously.
* However, this hook is useful to integrate other limited APIs into this event
* loop if they do not provide proper FD-abstractions.
*/
* Post-Dispatch Callbacks
* A post-dispatch cb is called whenever a single dispatch round is complete.
* You should avoid using them and instead not rely on any specific
- * dispatch-behavior but expect every event to be recieved asynchronously.
+ * dispatch-behavior but expect every event to be received asynchronously.
* However, this hook is useful to integrate other limited APIs into this event
* loop if they do not provide proper FD-abstractions.
*/
* kmscon_font_ref()/kmscon_font_unref() are used for reference counting.
* kmscon_font_render() renders a single unicode glyph and returns the glyph
* buffer. kmscon_font_drop() frees this buffer again. A kmscon_glyph object
- * contains a memory-buffer with the renderered glyph plus some metrics like
+ * contains a memory-buffer with the rendered glyph plus some metrics like
* height/width but also ascent/descent.
*
* Font-backends must take into account that this API must be thread-safe as it
* @backend: Backend to use or NULL for default backend
*
* Lookup a font by the given attributes. It uses the font backend @backend. If
- * it is NULL, the default backend is used. If the given backend cannot find the
+ * it is NULL, the default backend is used. If the given backend cannot find
* a suitable font, the fallback backend is tried. This backend should always
* find a suitable font.
*
* with each font. This guarantees that special characters like
* line-segments are properly aligned without spacing. If the font does
* not provide proper asc/desc values, then freetype2 will return proper
- * subsitutions. */
+ * substitutions. */
em = face->face->units_per_EM;
xsc = face->face->size->metrics.x_ppem / em;
}
/* TODO: Share the terminal-handling with the terminal-session. We
- * currently just create the screen/vte obejcts here to get meaningful
+ * currently just create the screen/vte objects here to get meaningful
* parsers. However, we should also correctly handled the terminal as is
* and draw it to the screen if in text-mode.
* This is nearly identical to the terminal-session so we should share
/*
* Resize terminal
* We support multiple monitors per terminal. As some software-rendering
- * backends to not support scaling, we always use the smalles cols/rows that are
+ * backends to not support scaling, we always use the smallest cols/rows that are
* provided so wider displays will have black margins.
* This can be extended to support scaling but that would mean we need to check
* whether the text-renderer backend supports that, first (TODO).
* file. If \file is NULL, then the default is used which is stderr.
* Messages are appended to the file and no file-locks are used so you cannot
* use a single file for multiple processes.
- * No log-file-roations or other backup/rotation functions are supported. Use a
+ * No log-file-rotations or other backup/rotation functions are supported. Use a
* proper init system like systemd to do this.
*
* log_print_init(appname):
* sev: Severity of log-message. An integer between 0 and 7 as defined below.
* These are identical to the linux-kernel severities so there is no need
* to include these in your public API. Every app can define them
- * themself, if they need it.
+ * themselves, if they need it.
* format: Format string. Must not be NULL.
* args: Argument array
*
*/
/*
- * Fragement Shader
+ * Fragment Shader
* A basic fragment shader which applies a 2D texture.
*/
*/
/*
- * Fragement Shader
+ * Fragment Shader
* A basic fragment shader which applies a 2D texture.
*/
*/
/*
- * Default Fragement Shader
+ * Default Fragment Shader
* A basic fragment shader which applies a color directly.
*/
*/
/*
- * Fragement Shader
+ * Fragment Shader
* A basic fragment shader which applies a 2D texture and blends foreground and
* background colors.
*/
#define FLAG_LINE_FEED_NEW_LINE_MODE 0x00000004 /* DEC line-feed/new-line mode */
#define FLAG_8BIT_MODE 0x00000008 /* Disable UTF-8 mode and enable 8bit compatible mode */
#define FLAG_7BIT_MODE 0x00000010 /* Disable 8bit mode and use 7bit compatible mode */
-#define FLAG_USE_C1 0x00000020 /* Explicitely use 8bit C1 codes; TODO: implement */
+#define FLAG_USE_C1 0x00000020 /* Explicitly use 8bit C1 codes; TODO: implement */
#define FLAG_KEYBOARD_ACTION_MODE 0x00000040 /* Disable keyboard; TODO: implement? */
#define FLAG_INSERT_REPLACE_MODE 0x00000080 /* Enable insert mode */
#define FLAG_SEND_RECEIVE_MODE 0x00000100 /* Disable local echo */
/* Switching to VT100 compatibility mode. We do
* not support this mode, so ignore it. In fact,
* we are almost compatible to it, anyway, so
- * there is no need to explicitely select it.
+ * there is no need to explicitly select it.
* However, we enable 7bit mode to avoid
* character-table problems */
vte->flags |= FLAG_7BIT_MODE;
* VT3xx up to VT5xx use it as 8bit mode. We
* choose to conform with the latter here.
* We also enable 8bit mode when VT220
- * compatibility is requested explicitely. */
+ * compatibility is requested explicitly. */
if (vte->csi_argv[1] == 1 ||
vte->csi_argv[1] == 2)
vte->flags |= FLAG_USE_C1;
continue;
case 3: /* DECCOLM */
/* If set, select 132 column mode, otherwise use 80
- * column mode. If neither is selected explicitely, we
+ * column mode. If neither is selected explicitly, we
* use dynamic mode, that is, we send SIGWCH when the
* size changes and we allow arbitrary buffer
* dimensions. On soft-reset, we automatically fall back
* to the default, that is, dynamic mode.
* Dynamic-mode can be forced to a static mode in the
- * config. That is, everytime dynamic-mode becomes
+ * config. That is, every time dynamic-mode becomes
* active, the terminal will be set to the dimensions
* that were selected in the config. This allows setting
* a fixed size for the terminal regardless of the
[STATE_NUM] = ACTION_NONE,
};
-/* perform state transision and dispatch related actions */
+/* perform state transition and dispatch related actions */
static void do_trans(struct tsm_vte *vte, uint32_t data, int state, int act)
{
if (state != STATE_NONE) {
* DEC special graphics character set. See here for its definition:
* http://vt100.net/docs/vt220-rm/table2-4.html
* This contains several characters to create ASCII drawings and similar. Its
- * commonaly mapped into GR to extend the basic ASCII characters.
+ * commonly mapped into GR to extend the basic ASCII characters.
*
* Lower 62 characters map to ASCII 33-64, everything beyond is special and
* commonly used for ASCII drawings. It depends on the Unicode Standard 3.2 for
* notification to the application via callbacks.
*
* Real VTs are only available on seat0 and should be avoided whenever possible
- * as they have a horrible API, have synchronization issues and are unflexible.
+ * as they have a horrible API, have synchronization issues and are inflexible.
*
* Also note that the VT API is asynchronous and requires acknowledgment of
* applications when switching VTs. That means, when a VT-switch is started, the
* by the currently active VT.
* Furthermore, there are some race-conditions during a switch. If resources
* that are passed from one VT to another are acquired during this switch from a
- * 3rd party application, then they can highjack the VT-switch and make the new
+ * 3rd party application, then they can hijack the VT-switch and make the new
* VT fail acquiring the resources.
*
* There are a lot more issues. For instance VTs are not cleaned up when closed
/*
* Fake VT:
* For systems without CONFIG_VT or for all seats that have no real VTs (which
- * is all seats except seat0), we support a fake-VT mechanism. This machanism is
+ * is all seats except seat0), we support a fake-VT mechanism. This mechanism is
* only used for debugging and should not be used in production.
*
* Fake-VTs react on a key-press and activate themselves if not active. If they
- * are already active, they deactivate themself. To switch from one fake-VT to
+ * are already active, they deactivate themselves. To switch from one fake-VT to
* another, you first need to deactivate the current fake-VT and then activate
* the new fake-VT. This also means that you must use different hotkeys for each
* fake-VT.
/* We are a catch-all handler. That is, we use all space that is
* available. We must be called _last_, which is guaranteed by
* registering the widget as last widget.
- * All previous handlers put their size constraints into the arguemnts
+ * All previous handlers put their size constraints into the arguments
* and we need to make sure to not break them.
* Every redraw-handler is guaranteed to work for every size, but still,
* we should try to avoid invalid-sizes to not generate artifacts. */
projects / platform / upstream / kmscon.git / commitdiff