negotiate explicitly registered IRC capabilities

make dialog content fill available space

docs/_static/css/zoitechat-docs.css

@@ -78,6 +78,11 @@ a {
     text-decoration: none;
 }
 
+::selection {
+    background: var(--accent);
+    color: #fff8ea;
+}
+
 button,
 input,
 textarea,
@@ -139,6 +144,7 @@ select {
     z-index: 2000;
     border-bottom: 3px solid var(--rule);
     background: rgba(238, 229, 211, 0.94);
+    -webkit-backdrop-filter: blur(8px);
     backdrop-filter: blur(8px);
 }
 
@@ -231,6 +237,17 @@ select {
     font-weight: 900;
 }
 
+.site-nav a[aria-current="page"] {
+    border-block-color: var(--rule);
+    background: var(--panel-dark);
+    color: var(--paper-warm);
+    box-shadow: inset 0 -0.3rem 0 var(--accent);
+}
+
+.site-nav a[aria-current="page"]::before {
+    color: #d19b25;
+}
+
 .site-nav a:hover,
 .site-nav a:focus-visible {
     border-block-color: var(--rule);
@@ -511,6 +528,7 @@ select {
     font-weight: 900;
     line-height: 1.18;
     box-shadow: 4px 4px 0 var(--rule);
+    touch-action: manipulation;
     transition: transform 0.12s ease, background-color 0.12s ease, color 0.12s ease, box-shadow 0.12s ease;
 }
 
@@ -527,6 +545,11 @@ select {
     outline: none;
 }
 
+.button:active {
+    transform: translate(3px, 3px);
+    box-shadow: none;
+}
+
 .button-primary {
     background: var(--accent);
     color: #fff8ea;
@@ -1176,6 +1199,11 @@ select {
     color: rgba(255, 248, 234, 0.82);
 }
 
+.footer-links a {
+    width: fit-content;
+    border-bottom: 1px solid transparent;
+}
+
 .footer-links a::before {
     color: #d19b25;
     content: "↳ ";
@@ -1184,6 +1212,7 @@ select {
 .footer-links a:hover,
 .footer-links a:focus-visible {
     color: #fff8ea;
+    border-bottom-color: currentColor;
     outline: none;
 }
 
@@ -1346,6 +1375,70 @@ select {
         animation-iteration-count: 1 !important;
     }
 }
+
+/* Automatic dark appearance, matching the main ZoiteChat site palette. */
+@media (prefers-color-scheme: dark) {
+    :root {
+        color-scheme: dark;
+        --paper: #161514;
+        --paper-warm: #f4ead9;
+        --paper-cool: #1c2522;
+        --ink: #f2eadb;
+        --ink-soft: #ddd2c1;
+        --muted: #bdb19f;
+        --quiet: #928777;
+        --rule: #080706;
+        --rule-soft: rgba(242, 234, 219, 0.16);
+        --rule-mid: rgba(242, 234, 219, 0.3);
+        --panel: #211e1a;
+        --panel-alt: #2b261f;
+        --panel-dark: #0b0c0c;
+        --accent: #c34720;
+        --accent-dark: #ff966d;
+        --accent-soft: rgba(195, 71, 32, 0.17);
+        --green: #367662;
+        --blue: #386b8d;
+        --warning: #9b6508;
+        --success: #43856a;
+        --shadow: 8px 8px 0 rgba(0, 0, 0, 0.82);
+        --shadow-soft: 0 18px 40px rgba(0, 0, 0, 0.36);
+    }
+
+    html {
+        background: var(--paper);
+    }
+
+    body {
+        background:
+            linear-gradient(90deg, rgba(242, 234, 219, 0.025) 1px, transparent 1px) 0 0 / 68px 68px,
+            linear-gradient(180deg, rgba(242, 234, 219, 0.022) 1px, transparent 1px) 0 0 / 68px 68px,
+            radial-gradient(circle at 11% 18%, rgba(195, 71, 32, 0.15), transparent 24rem),
+            radial-gradient(circle at 86% 4%, rgba(54, 118, 98, 0.16), transparent 28rem),
+            linear-gradient(180deg, #181715 0%, #111311 58%, #191714 100%);
+    }
+
+    body::before {
+        background:
+            repeating-linear-gradient(90deg, transparent 0 17px, rgba(242, 234, 219, 0.025) 17px 18px),
+            repeating-linear-gradient(0deg, transparent 0 5px, rgba(255, 255, 255, 0.025) 5px 6px);
+        mix-blend-mode: screen;
+    }
+
+    .site-header {
+        background: rgba(22, 21, 20, 0.94);
+    }
+
+    .site-nav a,
+    .nav-menu summary {
+        background: rgba(39, 35, 30, 0.52);
+    }
+
+    .eyebrow::before,
+    .footer-links a::before {
+        color: #e0aa3c;
+    }
+}
+
 /* Sphinx/Read the Docs bridge: aggressively map documentation onto the main ZoiteChat site skin. */
 html {
     font-size: 16px !important;
@@ -1485,6 +1578,17 @@ body a {
     font-weight: 900 !important;
 }
 
+#navbar-top .site-nav a[aria-current="page"] {
+    border-block-color: var(--rule) !important;
+    background: var(--panel-dark) !important;
+    color: var(--paper-warm) !important;
+    box-shadow: inset 0 -0.3rem 0 var(--accent) !important;
+}
+
+#navbar-top .site-nav a[aria-current="page"]::before {
+    color: #d19b25 !important;
+}
+
 #navbar-top .site-nav a:hover,
 #navbar-top .site-nav a:focus-visible,
 #navbar-top .site-nav summary:hover,
@@ -1671,6 +1775,7 @@ footer.site-footer-lite {
 }
 
 .document .body p {
+    max-width: 78ch;
     margin: 0 0 1rem !important;
 }
 
@@ -1716,6 +1821,7 @@ ul.search a:focus-visible {
 
 .document .body ul,
 .document .body ol {
+    max-width: 78ch;
     margin: 0.75rem 0 1.4rem !important;
     padding-left: 1.35rem !important;
 }
@@ -1865,6 +1971,11 @@ ul.search a:focus-visible {
     text-transform: uppercase !important;
 }
 
+.document .body table tbody tr:hover td,
+.document .body table tbody tr:focus-within td {
+    background: var(--accent-soft) !important;
+}
+
 .admonition,
 .note,
 .warning,
@@ -2004,6 +2115,7 @@ input[type="submit"],
     line-height: 1.18 !important;
     text-shadow: none !important;
     box-shadow: 4px 4px 0 var(--rule) !important;
+    touch-action: manipulation;
 }
 
 .btn:hover,
@@ -2019,6 +2131,13 @@ input[type="submit"]:focus-visible {
     outline: none !important;
 }
 
+.btn:active,
+button:active,
+input[type="submit"]:active {
+    transform: translate(3px, 3px) !important;
+    box-shadow: none !important;
+}
+
 #navbar-related {
     min-height: auto !important;
     margin: 1rem 0 1.5rem !important;
@@ -2275,3 +2394,37 @@ footer:not(.site-footer) {
         letter-spacing: -0.04em !important;
     }
 }
+
+/* Keep basicstrap's stronger overrides readable with the main site's dark palette. */
+@media (prefers-color-scheme: dark) {
+    #navbar-top.site-header {
+        background: rgba(22, 21, 20, 0.94) !important;
+    }
+
+    #navbar-top .site-nav a,
+    #navbar-top .site-nav summary {
+        background: rgba(39, 35, 30, 0.52) !important;
+    }
+
+    .document::after,
+    .sidebar::after,
+    #navbar-related::after {
+        background: linear-gradient(135deg, transparent 50%, rgba(242, 234, 219, 0.09) 50%) !important;
+    }
+
+    input[type="text"],
+    input[type="search"],
+    .search-query,
+    .form-control,
+    textarea,
+    select {
+        background: var(--panel) !important;
+        box-shadow: inset 3px 3px 0 rgba(0, 0, 0, 0.32) !important;
+    }
+
+    .warning,
+    .caution,
+    .danger {
+        background: #3a2e19 !important;
+    }
+}

docs/_theme/basicstrap/layout.html

@@ -209,6 +209,8 @@
     {%- endif %}
     <meta name="description" content="">
     <meta name="author" content="">
+    <meta name="theme-color" content="#eee5d3" media="(prefers-color-scheme: light)">
+    <meta name="theme-color" content="#161514" media="(prefers-color-scheme: dark)">
 
     {{ css() }}
     {%- if not embedded %}
@@ -260,8 +262,9 @@
         <nav class="site-nav" aria-label="Primary">
           <a href="https://zoitechat.org/">Home</a>
           <a href="https://zoitechat.org/addons.php">Addons</a>
+          <a href="https://zoitechat.org/announcements.php">Announcements</a>
           <a href="https://zoitechat.org/download.php">Download</a>
-          <a href="{{ pathto(master_doc) }}">Docs</a>
+          <a href="{{ pathto(master_doc) }}" aria-current="page">Docs</a>
           <a href="https://github.com/ZoiteChat/zoitechat" target="_blank" rel="noopener">GitHub</a>
           <details class="nav-menu">
             <summary>IRC Support</summary>
@@ -336,6 +339,7 @@
           <div class="footer-links">
             <a href="https://zoitechat.org/download.php">Download</a>
             <a href="https://zoitechat.org/addons.php">Addons</a>
+            <a href="https://zoitechat.org/announcements.php">Announcements</a>
             <a href="https://zoitechat.org/privacy.php">Privacy Policy</a>
             <a href="{{ pathto(master_doc) }}">Documentation</a>
             <a href="https://github.com/ZoiteChat/zoitechat" target="_blank" rel="noopener">Source code</a>

docs/plugin-api-additions/async.md

@@ -0,0 +1,30 @@
+# Optional Python asyncio integration
+
+`run_async(coroutine, context=None, interval=10)` returns an AsyncTask with
+`done()`, `cancel()` and `result()`. Each invocation owns a separate event loop
+pumped by an existing main-loop timer. A ready stop callback ensures selector
+polling never blocks the UI. The captured context is restored after every pump;
+a closed context cancels the work. No process-wide event-loop policy is changed.
+
+Existing synchronous scripts are unaffected. Use `asyncio.get_running_loop()`
+inside the coroutine. Child tasks use the same loop/context and are cancelled
+when the main coroutine finishes or the script unloads. Cancellation cleanup is
+bounded; tasks must not suppress cancellation indefinitely. Cleanup uses the
+captured context while it remains open; after it closes, cancellation cleanup uses
+the current valid context. Use explicit Context methods for context-specific
+output in finally blocks, and do not issue context-dependent commands there. This provides normal
+asyncio sockets/timers, not Windows subprocess support or a new HTTP library.
+Asyncio hostname resolution can use its executor; use a resolver appropriate to
+your library if you require no worker threads. Blocking work inside a coroutine
+still blocks the client and must be avoided.
+
+```python
+import asyncio
+import zoitechat
+
+async def later():
+    await asyncio.sleep(1)
+    zoitechat.prnt('Still in the context where this task was started')
+
+task = zoitechat.run_async(later())
+```

docs/plugin-api-additions/caps.md

@@ -0,0 +1,35 @@
+# Script-supported capabilities
+
+`register_capability(name, userdata=None, connection_id=None)` returns a normal
+hook handle. Register before connecting/reconnecting. Core requests the name only
+if advertised in CAP LS or CAP NEW. Existing built-in requests remain enabled;
+SASL and STS registration is rejected so scripts cannot change authentication or
+transport policy through this API. None/-1 means any connection (zero is a valid
+connection ID). Names are lowercase ASCII alphanumerics plus - . / _, 1-200 bytes.
+Duplicate registrations do not duplicate requests for an advertised token.
+
+`unhook(handle)` or script/plugin unload removes future request ownership. It
+intentionally does not disable a capability already acknowledged on a live
+connection, because another plugin/core may depend on it. Registering after CAP
+LS does not retrospectively negotiate an already-advertised capability: reconnect
+or wait for CAP NEW. Core retains ownership of CAP END; this API does not extend
+SASL waiting or delay registration awaiting plugin-only CAP ACKs.
+
+`hook_capability(name, callback, userdata=None, priority=PRI_NORM)` independently
+observes negotiation through existing raw CAP hooks. Callback receives
+`(CapabilityEvent, userdata)` with name, subcommand, value, enabled, context and
+connection_id. LS/NEW mean advertised (`enabled=None`), ACK/LIST mean enabled
+(unless a negative ACK), NAK means rejected and DEL means removed. Callback
+returns are ignored so this observer cannot eat core negotiation. Existing raw
+hooks may still eat CAP before this hook according to their normal priorities.
+
+C: `zoitechat_register_capability(ph, name, flags, connection_id, userdata)`;
+flags=0, ID=-1 for any. Check get_info("api_plugin_caps") for "1" before using
+the appended Windows slot. Use existing server CAP hooks for notifications.
+Requests are split at complete token boundaries within the existing wire limit.
+
+```python
+registration = zoitechat.register_capability('draft/example')
+zoitechat.hook_capability('draft/example', lambda event, data:
+                         event.context.prnt('{}: {}'.format(event.subcommand, event.enabled)))
+```

docs/plugin-api-additions/compatibility.md

@@ -0,0 +1,24 @@
+# Optional plugin API additions (discussion #144)
+
+Existing hooks, callbacks, return values, context lookup, strings and menu behaviour
+remain unchanged. The C plugin function table gains four fixed append-only slots;
+unused slots are NULL. Older binaries use the unchanged prefix. A plugin must check
+the documented get_info() feature key before accessing a new slot on an older host.
+New Python modules are installed by Meson and the existing Windows copy/installer
+pipeline. Only modules present in the installation are exported; imports of
+zoitechat, hexchat and xchat retain their compatibility aliases.
+
+All APIs run on the client main thread unless explicitly documented otherwise.
+New reserved flags must be zero. These changes do not make old API calls thread-safe.
+
+Nested hook dispatch defers deleted-hook reclamation until its outermost return,
+so new observers can safely emit events and unhook themselves or other hooks.
+
+The optional asyncio module requires Python 3.7 or newer; older supported
+interpreters skip that module and retain the existing scripting API.
+
+Python reload drops the script/API modules while retaining the embedding module
+so callback and lib.ph pointer types keep the same CFFI identity.
+
+Server-hook insertion matches both raw and attrs hooks so documented priorities
+are honoured for mixed registrations, including new filtered attrs callbacks.

docs/plugin-api-additions/contexts.md

@@ -0,0 +1,24 @@
+# Connection and context navigation
+
+`get_connections()` returns one Connection snapshot per live connection:
+`id`, `network`, `server`, `context`. Connection IDs distinguish simultaneous
+connections with identical names. Prefer its server-tab context where present.
+`get_connection(context=None)` finds the owner of a live context.
+
+`get_contexts(connection_id=None, types=None)` lists live contexts, optionally
+filtered by connection ID (or a Connection object) and session types: server=1,
+channel=2, query=3. `connection.contexts(types=None)` is a convenience method.
+`find_context_by_id(connection_id, channel=None)` / `connection.find(channel)`
+resolve using that connection's IRC comparator; no channel selects the server tab.
+Missing/closed contexts return None. Existing find_context() remains unchanged.
+
+These helpers use the existing channels list's ID/context fields, so no new C
+context ABI is needed. Snapshots are not persistent IDs across client restarts;
+refresh them after closing/recreating connections. Always check Context.set()
+when explicitly selecting a context that might have closed.
+
+```python
+connection = zoitechat.get_connection()
+for context in connection.contexts(types=(2,)):
+    context.prnt('A channel on this exact connection')
+```

docs/plugin-api-additions/events.md

@@ -0,0 +1,26 @@
+# Semantic IRC hooks
+
+`on_join`, `on_part`, `on_quit`, `on_nick`, `on_kick`, `on_message`, and
+`on_notice` accept `(callback, userdata=None, priority=PRI_NORM)`. The general
+form is `hook_event(command, callback, userdata=None, priority=PRI_NORM)`.
+Callbacks receive `(event, userdata)`, where the immutable IRCEvent has
+command, prefix, nick, user, host, params, context, connection_id and time.
+`params` preserves the trailing parameter, including spaces; JOIN parameters
+also retain extended-join account/realname data when supplied by the server.
+
+These wrappers use existing server hooks, before core command processing;
+return the ordinary EAT_* constants. EAT_ZOITECHAT suppresses the entire IRC
+command (including client state updates), not just its text. Use EAT_NONE for
+observation. Other plugins' priority and eating rules remain unchanged.
+The context is the core-selected context, which can be the server tab when a
+query/channel does not yet exist. QUIT is one event per incoming command,
+not one callback per affected channel. `event.time` is the existing server-time
+attribute (zero when unavailable); other message tags are not exposed here.
+
+```python
+def joined(event, userdata):
+    event.context.prnt('{} joined {}'.format(event.nick, event.params[0]))
+    return zoitechat.EAT_NONE
+
+zoitechat.on_join(joined)
+```

docs/plugin-api-additions/fd.md

@@ -0,0 +1,19 @@
+# Python descriptor hooks
+
+`hook_fd(fd, callback, userdata=None, flags=FD_READ)` returns an ordinary hook
+handle accepted by `unhook()`. Callback arguments are `(fd, ready_flags, userdata)`;
+return True to retain the watch and False/None to remove it. Exceptions print a
+traceback and remove the watch. Unloading the script removes its watches.
+The callback runs in the context captured during registration, and that context
+is restored afterwards. A closed context removes the watch.
+
+Use nonblocking IO and bounded reads/writes. The descriptor belongs to the script;
+unhook before closing it. On Windows socket descriptors use the default flags;
+CRT descriptors need FD_NOTSOCKET. The existing C API uses int descriptors: values
+outside its range are rejected rather than truncated. This does not add threads.
+
+Example:
+```python
+watch = zoitechat.hook_fd(sock.fileno(), on_readable, flags=zoitechat.FD_READ)
+# def on_readable(fd, flags, userdata): ...; return True
+```

docs/plugin-api-additions/filters.md

@@ -0,0 +1,24 @@
+# Core-filtered hooks
+
+Python: `hook_server_filtered(name, callback, userdata=None, priority=PRI_NORM,
+connection_id=None, channel=None)` and `hook_print_filtered(...)`.
+Callbacks match the existing attrs variants: `(word, word_eol, userdata, attrs)`.
+The connection ID distinguishes duplicate names; None/-1 means any connection
+(including connection ID zero). A channel restriction uses that connection's
+IRC comparator. None means any context; an empty string is an exact restriction.
+
+C: the corresponding zoitechat_hook_*_filtered functions accept
+`(ph, name, pri, flags, connection_id, channel, callback, userdata)`;
+flags=0, ID=-1 for any and NULL channel for any. Check
+`get_info("api_context_filters")` for "1" before accessing the new Windows slots.
+
+Filtering takes place before Python/interpreter entry. Existing unrestricted
+hooks, priority, EAT semantics and unload/unhook handling are unchanged.
+Filters refer to the core-selected context, not an IRC target parsed from the
+line: unknown queries/channels can still have a server-tab context, and QUIT
+has its usual single server-hook context. Connection IDs last only this process.
+
+```python
+zoitechat.hook_print_filtered('Channel Message', callback,
+                             connection_id=zoitechat.get_prefs('id'), channel='#zoitechat')
+```

docs/plugin-api-additions/names.md

@@ -0,0 +1,21 @@
+# Explicit IRC comparison keys
+
+`IRCName(text, context=None, casemapping=None, connection_id=None)` is an
+immutable helper, not a str subclass. Construct it explicitly for dictionary/set
+keys; existing get_info/list/event values remain normal strings.
+Equality and hashing include the connection ID and captured casemapping, so
+identical-looking names on different connections are different keys. An IRCName
+never compares equal to a plain str. `str(key)` / `key.text` recover the spelling.
+
+`irc_casefold(text, casemapping='rfc1459')` supports ascii, strict-rfc1459 and
+rfc1459. Only ASCII IRC characters fold; Unicode casefold would be incorrect.
+The new `get_info('casemapping')` reports the comparator actually used by core.
+Current master handles ASCII and RFC1459; this patch does not change its handling
+of advertised strict-rfc1459. An explicit mapping is available for scripts that
+need strict-rfc1459 independently. Keys capture their mapping so hashes stay
+stable; rebuild a collection if the connection's mapping changes.
+
+```python
+seen = {zoitechat.IRCName('[SomeNick]')}
+assert zoitechat.IRCName('{somenick}') in seen  # RFC1459 connection
+```

docs/plugin-api-additions/post.md

@@ -0,0 +1,21 @@
+# Post-display print observers
+
+Python: `hook_print_after(name, callback, userdata=None, priority=PRI_NORM)`.
+The callback is `(word, word_eol, userdata, attrs)`, matching hook_print_attrs().
+It runs after display_event() has handled the text, so prnt() follows the original
+text. Return values are ignored. Events eaten by a pre-hook or hidden by client
+preferences do not invoke these observers. This is post-display notification,
+not a notification that the entire incoming IRC command has finished updating state.
+
+C: `zoitechat_hook_print_after(ph, name, priority, flags, callback, userdata)`;
+flags must be zero. Check `get_info("api_hook_print_after")` for "1" before
+accessing the appended Windows function-table slot. Existing pre-hook timing is
+unchanged. Unhook/unload use existing lifecycle functions. Recursive emission
+skips an already-running observer to prevent it immediately invoking itself.
+
+```python
+def after(word, word_eol, userdata, attrs):
+    zoitechat.prnt('This follows the original channel message')
+
+zoitechat.hook_print_after('Channel Message', after)
+```

plugins/fishlim/plugin_zoitechat.c

@@ -710,6 +710,7 @@ static int handle_fishlim(char *word[], char *word_eol[], void *userdata) {
     gtk_box_pack_start(GTK_BOX(content), grid, TRUE, TRUE, 0);
 
     fishlim_target_entry = gtk_entry_new();
+    gtk_widget_set_hexpand(fishlim_target_entry, TRUE);
     if (target)
         gtk_entry_set_text(GTK_ENTRY(fishlim_target_entry), target);
     gtk_grid_attach(GTK_GRID(grid), gtk_label_new("Target nick or channel"), 0, 0, 1, 1);
@@ -760,6 +761,7 @@ static int handle_fishlim(char *word[], char *word_eol[], void *userdata) {
     g_signal_connect(view, "row-activated", G_CALLBACK(fishlim_gui_row_activated), NULL);
 
     scroll = gtk_scrolled_window_new(NULL, NULL);
+    gtk_widget_set_hexpand(scroll, TRUE);
     gtk_widget_set_vexpand(scroll, TRUE);
     gtk_container_add(GTK_CONTAINER(scroll), view);
     gtk_grid_attach(GTK_GRID(grid), scroll, 0, 6, 3, 1);

plugins/python/_zoitechat.py

@@ -383,3 +383,24 @@ def find_context(server=None, channel=None):
         return None
 
     return Context(ctx)
+
+
+# Optional additive APIs live in separate modules so builds can select features.
+def __load_additive_features():
+    import importlib
+    import os
+
+    for suffix in ('fd', 'events', 'async', 'names', 'contexts',
+                   'post', 'filters', 'caps'):
+        if suffix == 'async' and sys.version_info < (3, 7):
+            continue
+        name = '_zoitechat_' + suffix
+        if not os.path.isfile(os.path.join(os.path.dirname(__file__), name + '.py')):
+            continue
+        module = importlib.import_module(name)
+        for symbol in module.__all__:
+            globals()[symbol] = getattr(module, symbol)
+            __all__.append(symbol)
+
+
+__load_additive_features()

plugins/python/_zoitechat_async.py

@@ -0,0 +1,100 @@
+"""Opt-in asyncio tasks pumped without blocking the client main loop."""
+import asyncio
+import operator
+import traceback
+import _zoitechat as api
+
+__all__ = ['AsyncTask', 'run_async']
+
+
+class AsyncTask:
+    """A script-owned task and isolated event loop; cancel() is cooperative."""
+    def __init__(self, coroutine, plugin, context, interval):
+        self._plugin = plugin
+        self._context = context
+        self._loop = asyncio.new_event_loop()
+        self._task = self._loop.create_task(coroutine)
+        self._closed = False
+        self._unload_hook = api.hook_unload(lambda data: self._close())
+        self._timer_hook = api.hook_timer(interval, self._tick)
+
+    def done(self):
+        return self._task.done()
+
+    def cancel(self):
+        if not self._closed:
+            return self._task.cancel()
+        return False
+
+    def result(self):
+        return self._task.result()
+
+    def _pump(self):
+        # A ready stop callback forces the selector's timeout to zero.
+        self._loop.call_soon(self._loop.stop)
+        self._loop.run_forever()
+
+    def _close(self):
+        if self._closed:
+            return
+        self._closed = True
+        previous = api.get_context()
+        self._context.set()
+        try:
+            pending = asyncio.all_tasks(self._loop)
+            for task in pending:
+                task.cancel()
+            # Bound cleanup work; tasks must cooperate with cancellation.
+            for unused in range(3):
+                if not any(not task.done() for task in pending):
+                    break
+                self._pump()
+            for task in pending:
+                if not task.done():
+                    self._loop.call_exception_handler({
+                        'message': 'Script task ignored cancellation during unload',
+                        'task': task,
+                    })
+        finally:
+            self._loop.close()
+            previous.set()
+
+    def _tick(self, userdata):
+        if self._closed:
+            return False
+        previous = api.get_context()
+        if not self._context.set():
+            self._close()
+            self._plugin.remove_hook(self._unload_hook)
+            return False
+        try:
+            self._pump()
+            if not self._task.done():
+                return True
+            try:
+                self._task.result()
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                traceback.print_exc()
+            self._close()
+            self._plugin.remove_hook(self._unload_hook)
+            return False
+        except Exception:
+            traceback.print_exc()
+            self._close()
+            self._plugin.remove_hook(self._unload_hook)
+            return False
+        finally:
+            previous.set()
+
+
+def run_async(coroutine, context=None, interval=10):
+    """Schedule a coroutine in a captured context; return an AsyncTask handle."""
+    interval = operator.index(interval)
+    if interval < 1 or interval > 2147483647:
+        raise ValueError('interval must be a positive C int in milliseconds')
+    if not asyncio.iscoroutine(coroutine):
+        raise TypeError('run_async expects a coroutine object')
+    plugin = api.__get_current_plugin()
+    return AsyncTask(coroutine, plugin, context or api.get_context(), interval)

plugins/python/_zoitechat_caps.py

@@ -0,0 +1,64 @@
+"""Script-owned capability requests and structured negotiation observations."""
+from collections import namedtuple
+import operator
+import _zoitechat as api
+from _zoitechat_embedded import ffi, lib
+
+__all__ = ['CapabilityEvent', 'register_capability', 'hook_capability']
+CapabilityEvent = namedtuple('CapabilityEvent',
+                            'name subcommand value enabled context connection_id')
+
+
+def register_capability(name, userdata=None, connection_id=None):
+    """Request an advertised capability on next negotiation; unhook releases ownership."""
+    connection_id = -1 if connection_id is None else operator.index(connection_id)
+    if connection_id < -1 or connection_id > 2147483647:
+        raise ValueError('connection_id must fit the C API; -1 means any')
+    plugin = api.__get_current_plugin()
+    hook = plugin.add_hook(None, userdata)
+    handle = lib.zoitechat_register_capability(lib.ph, name.encode(), 0,
+                                              connection_id, hook.handle)
+    if handle == ffi.NULL:
+        hook.is_unload = True
+        plugin.remove_hook(id(hook))
+        raise ValueError('invalid capability name, reserved capability or connection ID')
+    hook.zoitechat_hook = handle
+    return id(hook)
+
+
+def hook_capability(name, callback, userdata=None, priority=api.PRI_NORM):
+    """Observe LS/NEW/ACK/NAK/DEL/LIST; this hook does not itself request the capability."""
+    if not callable(callback):
+        raise TypeError('callback must be callable')
+
+    def dispatch(word, word_eol, data):
+        if not word_eol:
+            return api.EAT_NONE
+        line = word_eol[0]
+        if line.startswith(':'):
+            unused, separator, line = line.partition(' ')
+        parts = line.split(' ', 3)
+        if len(parts) != 4 or parts[0].upper() != 'CAP':
+            return api.EAT_NONE
+        subcommand, tokens = parts[2].upper(), parts[3]
+        if subcommand not in ('LS', 'NEW', 'ACK', 'NAK', 'DEL', 'LIST'):
+            return api.EAT_NONE
+        if tokens.startswith('* '):
+            tokens = tokens[2:]
+        tokens = tokens.lstrip(':')
+        for token in tokens.split():
+            negative = token.startswith('-')
+            cap, equals, value = token.lstrip('-').partition('=')
+            if cap != name:
+                continue
+            enabled = None
+            if subcommand in ('ACK', 'LIST'):
+                enabled = not negative
+            elif subcommand in ('DEL', 'NAK'):
+                enabled = False
+            event = CapabilityEvent(cap, subcommand, value if equals else None,
+                                    enabled, api.get_context(), api.get_prefs('id'))
+            callback(event, data)
+        return api.EAT_NONE  # observing CAP must not suppress core negotiation
+
+    return api.hook_server('CAP', dispatch, userdata, priority)

plugins/python/_zoitechat_contexts.py

@@ -0,0 +1,75 @@
+"""Navigate live connections by ID instead of ambiguous server/network names."""
+from collections import namedtuple
+import operator
+import _zoitechat as api
+
+__all__ = ['Connection', 'get_connections', 'get_connection', 'get_contexts',
+           'find_context_by_id']
+
+
+class Connection(namedtuple('_Connection', 'id network server context')):
+    __slots__ = ()
+
+    def contexts(self, types=None):
+        return get_contexts(self.id, types)
+
+    def find(self, channel=None):
+        return find_context_by_id(self.id, channel)
+
+
+def _id(connection):
+    return operator.index(connection.id if isinstance(connection, Connection) else connection)
+
+
+def get_connections():
+    """Return one snapshot per live connection, including disconnected ones."""
+    entries = api.get_list('channels')
+    by_id = {}
+    order = []
+    for entry in entries:
+        if entry.id not in by_id:
+            order.append(entry.id)
+        if entry.id not in by_id or entry.type == 1:
+            by_id[entry.id] = Connection(entry.id, entry.network, entry.server,
+                                         entry.context)
+    return [by_id[connection_id] for connection_id in order]
+
+
+def get_connection(context=None):
+    """Find the owning connection of a Context; return None when it has closed."""
+    context = context or api.get_context()
+    for entry in api.get_list('channels'):
+        if entry.context == context:
+            for connection in get_connections():
+                if connection.id == entry.id:
+                    return connection
+    return None
+
+
+def get_contexts(connection_id=None, types=None):
+    """Return contexts, optionally restricted to a connection and session types."""
+    if connection_id is not None:
+        connection_id = _id(connection_id)
+    if types is not None:
+        types = frozenset(types)
+    return [entry.context for entry in api.get_list('channels')
+            if (connection_id is None or entry.id == connection_id)
+            and (types is None or entry.type in types)]
+
+
+def find_context_by_id(connection_id, channel=None):
+    """Resolve a live context on exactly one connection; None selects its server tab."""
+    connection_id = _id(connection_id)
+    previous = api.get_context()
+    try:
+        for entry in api.get_list('channels'):
+            if entry.id != connection_id:
+                continue
+            if channel is None:
+                if entry.type == 1:
+                    return entry.context
+            elif entry.context.set() and api.nickcmp(entry.channel, channel) == 0:
+                return entry.context
+    finally:
+        previous.set()
+    return None

plugins/python/_zoitechat_events.py

@@ -0,0 +1,77 @@
+"""Structured, opt-in hooks before the IRC command's core processing."""
+from collections import namedtuple
+import _zoitechat as api
+
+__all__ = ['IRCEvent', 'hook_event', 'on_join', 'on_part', 'on_quit',
+           'on_nick', 'on_kick', 'on_message', 'on_notice']
+IRCEvent = namedtuple('IRCEvent', 'command prefix nick user host params context connection_id time')
+_SUPPORTED = frozenset(('JOIN', 'PART', 'QUIT', 'NICK', 'KICK', 'PRIVMSG', 'NOTICE'))
+
+
+def _parse(line):
+    prefix = ''
+    if line.startswith(':'):
+        prefix, separator, line = line[1:].partition(' ')
+        if not separator:
+            return None
+    command, separator, rest = line.partition(' ')
+    params = []
+    while rest:
+        rest = rest.lstrip(' ')
+        if rest.startswith(':'):
+            params.append(rest[1:])
+            break
+        param, separator, rest = rest.partition(' ')
+        if param:
+            params.append(param)
+    nick, marker, userhost = prefix.partition('!')
+    user, marker, host = userhost.partition('@')
+    return command.upper(), prefix, nick, user, host, tuple(params)
+
+
+def hook_event(command, callback, userdata=None, priority=api.PRI_NORM):
+    """callback(event, userdata) returns existing EAT_* constants."""
+    command = command.upper()
+    if command not in _SUPPORTED:
+        raise ValueError('unsupported semantic event: ' + command)
+    if not callable(callback):
+        raise TypeError('callback must be callable')
+
+    def dispatch(word, word_eol, data, attrs):
+        if not word_eol:
+            return api.EAT_NONE
+        parsed = _parse(word_eol[0])
+        if parsed is None or parsed[0] != command:
+            return api.EAT_NONE
+        event = IRCEvent(*(parsed + (api.get_context(), api.get_prefs('id'), attrs.time)))
+        return callback(event, data)
+
+    return api.hook_server_attrs(command, dispatch, userdata, priority)
+
+
+def on_join(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('JOIN', callback, userdata, priority)
+
+
+def on_part(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('PART', callback, userdata, priority)
+
+
+def on_quit(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('QUIT', callback, userdata, priority)
+
+
+def on_nick(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('NICK', callback, userdata, priority)
+
+
+def on_kick(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('KICK', callback, userdata, priority)
+
+
+def on_message(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('PRIVMSG', callback, userdata, priority)
+
+
+def on_notice(callback, userdata=None, priority=api.PRI_NORM):
+    return hook_event('NOTICE', callback, userdata, priority)

plugins/python/_zoitechat_fd.py

@@ -0,0 +1,39 @@
+"""File descriptor readiness hooks; callbacks execute on the main thread."""
+import operator
+import _zoitechat as api
+from _zoitechat_embedded import ffi, lib
+
+__all__ = ['FD_READ', 'FD_WRITE', 'FD_EXCEPTION', 'FD_NOTSOCKET', 'hook_fd']
+FD_READ, FD_WRITE, FD_EXCEPTION, FD_NOTSOCKET = 1, 2, 4, 8
+
+
+def hook_fd(fd, callback, userdata=None, flags=FD_READ):
+    """callback(fd, ready_flags, userdata): True keeps the watch, False removes it."""
+    fd = operator.index(fd)
+    flags = operator.index(flags)
+    if fd < 0 or fd > 2147483647:
+        raise ValueError('fd must fit the C API nonnegative int descriptor')
+    if flags & ~15 or not flags & 7:
+        raise ValueError('flags must select READ, WRITE or EXCEPTION')
+    if not callable(callback):
+        raise TypeError('callback must be callable')
+    plugin = api.__get_current_plugin()
+    context = api.get_context()
+
+    def dispatch(descriptor, ready, data):
+        previous = api.get_context()
+        if not context.set():
+            return False
+        try:
+            return callback(descriptor, ready, data)
+        finally:
+            previous.set()
+
+    hook = plugin.add_hook(dispatch, userdata)
+    handle = lib.zoitechat_hook_fd(lib.ph, fd, flags, lib._on_fd_hook, hook.handle)
+    if handle == ffi.NULL:
+        hook.is_unload = True
+        plugin.remove_hook(id(hook))
+        raise RuntimeError('unable to watch descriptor')
+    hook.zoitechat_hook = handle
+    return id(hook)

plugins/python/_zoitechat_filters.py

@@ -0,0 +1,36 @@
+"""Context restrictions evaluated by core before entering Python."""
+import operator
+import _zoitechat as api
+from _zoitechat_embedded import ffi, lib
+
+__all__ = ['hook_server_filtered', 'hook_print_filtered']
+
+
+def _register(name, callback, userdata, priority, connection_id, channel, server):
+    if not callable(callback):
+        raise TypeError('callback must be callable')
+    connection_id = -1 if connection_id is None else operator.index(connection_id)
+    if connection_id < -1 or connection_id > 2147483647:
+        raise ValueError('connection_id must fit the C API; -1 means any')
+    plugin = api.__get_current_plugin()
+    hook = plugin.add_hook(callback, userdata)
+    register = lib.zoitechat_hook_server_filtered if server else lib.zoitechat_hook_print_filtered
+    dispatch = lib._on_server_attrs_hook if server else lib._on_print_attrs_hook
+    handle = register(lib.ph, name.encode(), priority, 0, connection_id,
+                      ffi.NULL if channel is None else channel.encode(), dispatch, hook.handle)
+    if handle == ffi.NULL:
+        hook.is_unload = True
+        plugin.remove_hook(id(hook))
+        raise RuntimeError('unable to install filtered hook')
+    hook.zoitechat_hook = handle
+    return id(hook)
+
+
+def hook_server_filtered(name, callback, userdata=None, priority=api.PRI_NORM,
+                         connection_id=None, channel=None):
+    return _register(name, callback, userdata, priority, connection_id, channel, True)
+
+
+def hook_print_filtered(name, callback, userdata=None, priority=api.PRI_NORM,
+                        connection_id=None, channel=None):
+    return _register(name, callback, userdata, priority, connection_id, channel, False)

plugins/python/_zoitechat_names.py

@@ -0,0 +1,74 @@
+"""Explicit immutable IRC names; existing string-returning APIs are unchanged."""
+import _zoitechat as api
+
+__all__ = ['IRCName', 'irc_casefold']
+
+
+def irc_casefold(text, casemapping='rfc1459'):
+    """Fold ASCII IRC characters only; never apply Unicode lower()/casefold()."""
+    if casemapping not in ('ascii', 'strict-rfc1459', 'rfc1459'):
+        raise ValueError('unsupported IRC casemapping')
+    extra = {'[': '{', ']': '}', '\\': '|'} if casemapping != 'ascii' else {}
+    if casemapping == 'rfc1459':
+        extra['^'] = '~'
+    return ''.join(chr(ord(c) + 32) if 'A' <= c <= 'Z' else extra.get(c, c)
+                   for c in text)
+
+
+class IRCName:
+    """Equality/hash include connection identity and the captured casemapping."""
+    __slots__ = ('_text', '_casemapping', '_connection_id', '_key')
+
+    def __init__(self, text, context=None, casemapping=None, connection_id=None):
+        context = context or api.get_context()
+        if casemapping is None:
+            casemapping = context.get_info('casemapping')
+            if casemapping is None:
+                raise RuntimeError('host does not expose its comparison casemapping')
+        if connection_id is None:
+            previous = api.get_context()
+            if not context.set():
+                raise ValueError('context has closed')
+            try:
+                connection_id = api.get_prefs('id')
+            finally:
+                previous.set()
+        object.__setattr__(self, '_text', text)
+        object.__setattr__(self, '_casemapping', casemapping)
+        object.__setattr__(self, '_connection_id', connection_id)
+        object.__setattr__(self, '_key', (connection_id, casemapping,
+                                       irc_casefold(text, casemapping)))
+
+    def __setattr__(self, name, value):
+        raise AttributeError('IRCName is immutable')
+
+    @property
+    def text(self):
+        return self._text
+
+    @property
+    def casemapping(self):
+        return self._casemapping
+
+    @property
+    def connection_id(self):
+        return self._connection_id
+
+    def __str__(self):
+        return self._text
+
+    def __repr__(self):
+        return 'IRCName({!r}, casemapping={!r}, connection_id={!r})'.format(
+            self._text, self._casemapping, self._connection_id)
+
+    def __eq__(self, other):
+        if not isinstance(other, IRCName):
+            return NotImplemented
+        return self._key == other._key
+
+    def __ne__(self, other):
+        result = self.__eq__(other)
+        return NotImplemented if result is NotImplemented else not result
+
+    def __hash__(self):
+        return hash(self._key)

plugins/python/_zoitechat_post.py

@@ -0,0 +1,21 @@
+"""Opt-in post-display print observers."""
+import _zoitechat as api
+from _zoitechat_embedded import ffi, lib
+
+__all__ = ['hook_print_after']
+
+
+def hook_print_after(name, callback, userdata=None, priority=api.PRI_NORM):
+    """callback(word, word_eol, userdata, attrs); its return value is ignored."""
+    if not callable(callback):
+        raise TypeError('callback must be callable')
+    plugin = api.__get_current_plugin()
+    hook = plugin.add_hook(callback, userdata)
+    handle = lib.zoitechat_hook_print_after(lib.ph, name.encode(), priority, 0,
+                                           lib._on_print_attrs_hook, hook.handle)
+    if handle == ffi.NULL:
+        hook.is_unload = True
+        plugin.remove_hook(id(hook))
+        raise RuntimeError('unable to install post-display hook')
+    hook.zoitechat_hook = handle
+    return id(hook)

plugins/python/generate_plugin.py

@@ -38,6 +38,7 @@ extern "Python" int _on_print_attrs_hook(char **, zoitechat_event_attrs *, void
 extern "Python" int _on_server_hook(char **, char **, void *);
 extern "Python" int _on_server_attrs_hook(char **, char **, zoitechat_event_attrs *, void *);
 extern "Python" int _on_timer_hook(void *);
+extern "Python" int _on_fd_hook(int, int, void *);
 
 extern "Python" int _on_plugin_init(char **, char **, char **, char *, char *);
 extern "Python" int _on_plugin_deinit(void);

plugins/python/meson.build

@@ -27,7 +27,11 @@ python3_source = custom_target('python-bindings',
   command: [find_program('generate_plugin.py'), '@INPUT@', '@OUTPUT@']
 )
 
-install_data(['_zoitechat.py', 'zoitechat.py', 'xchat.py', 'hexchat.py'],
+# Include any selected additive API modules alongside the compatibility modules.
+python_api_files = run_command(python3, '-c',
+  'import glob,sys; print("\\n".join(sorted(glob.glob(sys.argv[1] + "/_zoitechat*.py"))))',
+  meson.current_source_dir(), check: true).stdout().strip().split('\n')
+install_data(python_api_files + ['zoitechat.py', 'xchat.py', 'hexchat.py'],
   install_dir: join_paths(get_option('libdir'), 'zoitechat/python')
 )
 

plugins/python/python.py

@@ -304,6 +304,28 @@ def _on_timer_hook(userdata):
     return 0
 
 
+@ffi.def_extern()
+def _on_fd_hook(fd, flags, userdata):
+    hook = ffi.from_handle(userdata)
+    keep = False
+    try:
+        keep = bool(hook.callback(fd, flags, hook.userdata))
+    except Exception:
+        traceback.print_exc()
+    if not keep:
+        # The C watch removes itself on return; do not unhook it a second time.
+        try:
+            hook.is_unload = True
+            # from_handle() yields a weak proxy: id(proxy) is not id(Hook).
+            for existing in hook.plugin.hooks:
+                if existing == hook:
+                    hook.plugin.remove_hook(id(existing))
+                    break
+        except ReferenceError:
+            pass  # the callback already unhooked itself
+    return int(keep)
+
+
 @ffi.def_extern()
 def _on_say_command(word, word_eol, userdata):
     """Handle input in the special >>python<< tab.
@@ -590,7 +612,12 @@ def _on_plugin_deinit():
     sys.stderr = sys.__stderr__
     pydoc.help = pydoc.Helper()
 
-    for mod in ('_zoitechat', 'zoitechat', 'xchat', '_zoitechat_embedded'):
+    # CFFI callbacks keep the embedding module's ffi/lib identity for the
+    # process lifetime; deleting it creates incompatible types on reload.
+    for mod in ('_zoitechat', 'zoitechat', 'hexchat', 'xchat',
+                '_zoitechat_fd', '_zoitechat_events', '_zoitechat_async',
+                '_zoitechat_names', '_zoitechat_contexts', '_zoitechat_post',
+                '_zoitechat_filters', '_zoitechat_caps'):
         try:
             del sys.modules[mod]
 

plugins/python/python3.vcxproj

@@ -52,6 +52,7 @@
     <None Include="xchat.py" />
     <None Include="hexchat.py" />
     <None Include="_zoitechat.py" />
+    <None Include="_zoitechat_*.py" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="$(IntDir)python.c" />

plugins/python/python38.vcxproj

@@ -52,6 +52,7 @@
     <None Include="xchat.py" />
     <None Include="hexchat.py" />
     <None Include="_zoitechat.py" />
+    <None Include="_zoitechat_*.py" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="$(IntDir)python.c" />

src/common/fe.h

@@ -70,6 +70,9 @@ void fe_add_rawlog (struct server *serv, char *text, int len, int outbound);
 #define FE_MSG_ERROR 8
 #define FE_MSG_MARKUP 16
 void fe_message (char *msg, int flags);
+#ifdef __linux__
+void fe_root_warning (void);
+#endif
 #define FIA_READ 1
 #define FIA_WRITE 2
 #define FIA_EX 4

src/common/inbound.c

@@ -41,6 +41,8 @@
 #include "network.h"
 #include "notify.h"
 #include "outbound.h"
+#include <gmodule.h>
+#include "plugin.h"
 #include "inbound.h"
 #include "server.h"
 #include "servlist.h"
@@ -1962,10 +1964,58 @@ inbound_cap_ack (server *serv, char *nick, char *extensions,
 	inbound_toggle_caps (serv, extensions, TRUE);
 }
 
+/* Split requests only at token boundaries, including plugin-added names. */
+static void
+inbound_cap_request_append (server *serv, char *buffer, gsize size,
+                            const char *name, time_t timestamp)
+{
+	if (strlen (buffer) + strlen (name) + 1 >= size)
+	{
+		EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPREQ, serv->server_session,
+			buffer + 9, NULL, NULL, NULL, 0, timestamp);
+		tcp_sendf (serv, "%s\r\n", g_strchomp (buffer));
+		g_strlcpy (buffer, "CAP REQ :", size);
+	}
+	g_strlcat (buffer, name, size);
+	g_strlcat (buffer, " ", size);
+}
+
+static void
+inbound_plugin_cap_new (server *serv, const char *extensions, time_t timestamp)
+{
+	char buffer[500] = "CAP REQ :";
+	char **tokens = g_strsplit (extensions, " ", 0);
+	GHashTable *seen = g_hash_table_new (g_str_hash, g_str_equal);
+	int i;
+	gboolean requested = FALSE;
+	for (i = 0; tokens[i]; i++)
+	{
+		char *value = strchr (tokens[i], '=');
+		if (value)
+			*value = '\0';
+		if (plugin_requests_capability (serv, tokens[i]) &&
+			!g_hash_table_contains (seen, tokens[i]))
+		{
+			g_hash_table_add (seen, tokens[i]);
+			inbound_cap_request_append (serv, buffer, sizeof (buffer), tokens[i], timestamp);
+			requested = TRUE;
+		}
+	}
+	if (requested)
+	{
+		EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPREQ, serv->server_session,
+			buffer + 9, NULL, NULL, NULL, 0, timestamp);
+		tcp_sendf (serv, "%s\r\n", g_strchomp (buffer));
+	}
+	g_hash_table_destroy (seen);
+	g_strfreev (tokens);
+}
+
 void
 inbound_cap_new (server *serv, char *nick, char *extensions,
 					 const message_tags_data *tags_data)
 {
+	gboolean sts_upgrade_triggered = FALSE;
 	if (extensions)
 	{
 		char **tokens = g_strsplit (extensions, " ", 0);
@@ -1977,7 +2027,7 @@ inbound_cap_new (server *serv, char *nick, char *extensions,
 
 			if (!g_strcmp0 (parts[0], "sts") && parts[1] && parts[1][0])
 			{
-				sts_handle_capability (serv, parts[1]);
+				sts_upgrade_triggered |= sts_handle_capability (serv, parts[1]);
 			}
 
 			g_strfreev (parts);
@@ -1986,6 +2036,9 @@ inbound_cap_new (server *serv, char *nick, char *extensions,
 		g_strfreev (tokens);
 	}
 
+	if (extensions && !sts_upgrade_triggered)
+		inbound_plugin_cap_new (serv, extensions, tags_data->timestamp);
+
 	EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPACK, serv->server_session, nick, extensions,
 								  NULL, NULL, 0, tags_data->timestamp);
 
@@ -2116,6 +2169,7 @@ inbound_cap_ls (server *serv, char *nick, char *extensions_str,
 	gboolean want_cap = FALSE; /* format the CAP REQ string based on previous capabilities being requested or not */
 	gboolean sts_upgrade_triggered = FALSE;
 	char **extensions;
+	GString *requests = g_string_new ("");
 	int i;
 
 	if (g_str_has_prefix (extensions_str, "* "))
@@ -2181,7 +2235,7 @@ inbound_cap_ls (server *serv, char *nick, char *extensions_str,
 			}
 			want_cap = TRUE;
 			serv->waiting_on_sasl = TRUE;
-			g_strlcat (buffer, "sasl ", sizeof(buffer));
+			g_string_append (requests, "sasl ");
 			continue;
 		}
 
@@ -2189,28 +2243,44 @@ inbound_cap_ls (server *serv, char *nick, char *extensions_str,
 		{
 			if (!g_strcmp0 (extension, supported_caps[x]))
 			{
-				g_strlcat (buffer, extension, sizeof(buffer));
-				g_strlcat (buffer, " ", sizeof(buffer));
+				g_string_append (requests, extension);
+				g_string_append_c (requests, ' ');
+				want_cap = TRUE;
+				break;
+			}
+		}
+		if (x == G_N_ELEMENTS (supported_caps) && plugin_requests_capability (serv, extension))
+		{
+			g_string_append (requests, extension);
+			g_string_append_c (requests, ' ');
 			want_cap = TRUE;
 		}
-		}
+
 	}
 
 	g_strfreev (extensions);
 
 	if (sts_upgrade_triggered)
 	{
+		g_string_free (requests, TRUE);
 		return;
 	}
 
 	if (want_cap)
 	{
+		char **tokens = g_strsplit (requests->str, " ", 0);
+		/* Defer every batch until STS has decided whether to reconnect. */
+		for (i = 0; tokens[i]; i++)
+			if (tokens[i][0])
+				inbound_cap_request_append (serv, buffer, sizeof (buffer), tokens[i], tags_data->timestamp);
+		g_strfreev (tokens);
 		/* buffer + 9 = emit buffer without "CAP REQ :" */
 		EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPREQ, serv->server_session,
 									  buffer + 9, NULL, NULL, NULL, 0,
 									  tags_data->timestamp);
 		tcp_sendf (serv, "%s\r\n", g_strchomp (buffer));
 	}
+	g_string_free (requests, TRUE);
 	if (!serv->waiting_on_sasl && !serv->waiting_on_cap)
 	{
 		/* if we use SASL, CAP END is dealt via raw numerics */

src/common/outbound.c

@@ -2826,6 +2826,7 @@ static gboolean
 client_tag_allowed (server *serv, const char *tag)
 {
 	char **deny;
+	gboolean blocked = FALSE;
 	int i;
 
 	if (!serv->have_message_tags)
@@ -2837,15 +2838,16 @@ client_tag_allowed (server *serv, const char *tag)
 	deny = g_strsplit (serv->clienttagdeny, ",", 0);
 	for (i = 0; deny[i]; i++)
 	{
-		if (!strcmp (deny[i], "*") || !strcmp (deny[i], tag) || (deny[i][0] == '+' && !strcmp (deny[i] + 1, tag)))
-		{
-			g_strfreev (deny);
-			return FALSE;
-		}
+		if (!strcmp (deny[i], "*"))
+			blocked = TRUE;
+		else if (deny[i][0] == '-' && !strcmp (deny[i] + 1, tag))
+			blocked = FALSE;
+		else if (!strcmp (deny[i], tag) || (deny[i][0] == '+' && !strcmp (deny[i] + 1, tag)))
+			blocked = TRUE;
 	}
 
 	g_strfreev (deny);
-	return TRUE;
+	return !blocked;
 }
 
 static char *

src/common/plugin.c

@@ -99,6 +99,10 @@ struct _zoitechat_hook
 	int tag;				/* for timers & FDs only */
 	int type;			/* HOOK_* */
 	int pri;	/* fd */	/* priority / fd for HOOK_FD only */
+	int cap_connection_id;
+	int connection_filter;
+	char *channel_filter;
+	gboolean context_filtered;
 };
 
 struct _zoitechat_list
@@ -143,6 +147,8 @@ enum
 	HOOK_PRINT_ATTRS  = 1 << 4, /* same as above, with attributes */
 	HOOK_TIMER        = 1 << 5, /* timeouts */
 	HOOK_FD           = 1 << 6, /* sockets & fds */
+	HOOK_PRINT_AFTER  = 1 << 8, /* opt-in post-display observers */
+	HOOK_CAPABILITY   = 1 << 9, /* script-owned CAP requests */
 	HOOK_DELETED      = 1 << 7  /* marked for deletion */
 };
 
@@ -176,6 +182,7 @@ enum
 
 GSList *plugin_list = NULL;	/* export for plugingui.c */
 static GSList *hook_list = NULL;
+static unsigned int plugin_dispatch_depth;
 
 extern const struct prefs vars[];	/* cfgfiles.c */
 
@@ -243,7 +250,7 @@ plugin_list_add (zoitechat_context *ctx, char *filename, const char *name,
 {
 	zoitechat_plugin *pl;
 
-	pl = g_new (zoitechat_plugin, 1);
+	pl = g_new0 (zoitechat_plugin, 1);
 	pl->handle = handle;
 	pl->filename = filename;
 	pl->context = ctx;
@@ -350,6 +357,10 @@ plugin_add (session *sess, char *filename, void *handle, void *init_func,
 		pl->zoitechat_emit_print_attrs = zoitechat_emit_print_attrs;
 		pl->zoitechat_event_attrs_create = zoitechat_event_attrs_create;
 		pl->zoitechat_event_attrs_free = zoitechat_event_attrs_free;
+		pl->zoitechat_register_capability = zoitechat_register_capability;
+		pl->zoitechat_hook_server_filtered = zoitechat_hook_server_filtered;
+		pl->zoitechat_hook_print_filtered = zoitechat_hook_print_filtered;
+		pl->zoitechat_hook_print_after = zoitechat_hook_print_after;
 
 		/* run zoitechat_plugin_init, if it returns 0, close the plugin */
 		if (((zoitechat_init_func *)init_func) (pl, &pl->name, &pl->desc, &pl->version, arg) == 0)
@@ -610,6 +621,7 @@ plugin_hook_run (session *sess, char *name, char *word[], char *word_eol[],
 	zoitechat_hook *hook;
 	int ret, eat = 0;
 
+	plugin_dispatch_depth++;
 	list = hook_list;
 	while (1)
 	{
@@ -619,6 +631,22 @@ plugin_hook_run (session *sess, char *name, char *word[], char *word_eol[],
 
 		hook = list->data;
 		next = list->next;
+		if (hook->context_filtered &&
+			(!is_session (sess) ||
+			 (hook->connection_filter != -1 && hook->connection_filter != sess->server->id) ||
+			 (hook->channel_filter && sess->server->p_cmp (hook->channel_filter, sess->channel))))
+		{
+			list = next;
+			continue; /* filter in C before entering an interpreter */
+		}
+
+		if (type == HOOK_PRINT_AFTER && hook->tag)
+		{
+			list = next;
+			continue; /* no recursive invocation of this same observer */
+		}
+		if (type == HOOK_PRINT_AFTER)
+			hook->tag = 1;
 		hook->pl->context = sess;
 
 		/* run the plugin's callback function */
@@ -627,6 +655,7 @@ plugin_hook_run (session *sess, char *name, char *word[], char *word_eol[],
 		case HOOK_COMMAND:
 			ret = ((zoitechat_cmd_cb *)hook->callback) (word, word_eol, hook->userdata);
 			break;
+		case HOOK_PRINT_AFTER:
 		case HOOK_PRINT_ATTRS:
 			ret = ((zoitechat_print_attrs_cb *)hook->callback) (word, attrs, hook->userdata);
 			break;
@@ -641,6 +670,15 @@ plugin_hook_run (session *sess, char *name, char *word[], char *word_eol[],
 			break;
 		}
 
+		if (type == HOOK_PRINT_AFTER)
+		{
+			hook->tag = 0;
+			if (!is_session (sess))
+				goto xit;
+			list = next;
+			continue; /* display already happened; observers cannot eat it */
+		}
+
 		if ((ret & ZOITECHAT_EAT_ZOITECHAT) && (ret & ZOITECHAT_EAT_PLUGIN))
 		{
 			eat = 1;
@@ -655,6 +693,10 @@ plugin_hook_run (session *sess, char *name, char *word[], char *word_eol[],
 	}
 
 xit:
+	/* Nested callbacks can unhook entries still used by an outer dispatch.
+	 * Keep both hook objects and list links alive until the outermost return. */
+	if (--plugin_dispatch_depth != 0)
+		return eat;
 	/* really remove deleted hooks now */
 	list = hook_list;
 	while (list)
@@ -719,6 +761,15 @@ plugin_emit_print (session *sess, char *word[], time_t server_time)
 							HOOK_PRINT | HOOK_PRINT_ATTRS);
 }
 
+void
+plugin_emit_print_after (session *sess, char *word[], time_t server_time)
+{
+	zoitechat_event_attrs attrs;
+	attrs.server_time_utc = server_time;
+	if (is_session (sess))
+		plugin_hook_run (sess, word[0], word, NULL, &attrs, HOOK_PRINT_AFTER);
+}
+
 int
 plugin_emit_dummy_print (session *sess, char *name)
 {
@@ -806,7 +857,7 @@ plugin_insert_hook (zoitechat_hook *new_hook)
 			break;
 		case HOOK_SERVER:
 		case HOOK_SERVER_ATTRS:
-			new_hook_type = HOOK_SERVER | HOOK_PRINT_ATTRS;
+			new_hook_type = HOOK_SERVER | HOOK_SERVER_ATTRS;
 			break;
 		default:
 			new_hook_type = new_hook->type;
@@ -1018,10 +1069,87 @@ zoitechat_unhook (zoitechat_plugin *ph, zoitechat_hook *hook)
 
 	g_free (hook->name);	/* NULL for timers & fds */
 	g_free (hook->help_text);	/* NULL for non-commands */
+	g_free (hook->channel_filter);
+	hook->channel_filter = NULL;
 
 	return hook->userdata;
 }
 
+zoitechat_hook *
+zoitechat_hook_print_after (zoitechat_plugin *ph, const char *name, int pri,
+                          int flags, zoitechat_print_attrs_cb *callback, void *userdata)
+{
+	if (flags != 0 || !name || !callback)
+		return NULL;
+	return plugin_add_hook (ph, HOOK_PRINT_AFTER, pri, name, NULL, callback, 0, userdata);
+}
+
+static zoitechat_hook *
+plugin_add_filtered_hook (zoitechat_plugin *ph, const char *name, int pri,
+                         int flags, int connection_id, const char *channel,
+                         int type, void *callback, void *userdata)
+{
+	zoitechat_hook *hook;
+	if (flags != 0 || connection_id < -1 || !name || !callback)
+		return NULL;
+	hook = plugin_add_hook (ph, type, pri, name, NULL, callback, 0, userdata);
+	hook->context_filtered = TRUE;
+	hook->connection_filter = connection_id;
+	hook->channel_filter = g_strdup (channel);
+	return hook;
+}
+
+zoitechat_hook *
+zoitechat_hook_server_filtered (zoitechat_plugin *ph, const char *name, int pri,
+                               int flags, int connection_id, const char *channel,
+                               zoitechat_serv_attrs_cb *callback, void *userdata)
+{
+	return plugin_add_filtered_hook (ph, name, pri, flags, connection_id, channel,
+		HOOK_SERVER_ATTRS, callback, userdata);
+}
+
+zoitechat_hook *
+zoitechat_hook_print_filtered (zoitechat_plugin *ph, const char *name, int pri,
+                              int flags, int connection_id, const char *channel,
+                              zoitechat_print_attrs_cb *callback, void *userdata)
+{
+	return plugin_add_filtered_hook (ph, name, pri, flags, connection_id, channel,
+		HOOK_PRINT_ATTRS, callback, userdata);
+}
+
+zoitechat_hook *
+zoitechat_register_capability (zoitechat_plugin *ph, const char *name, int flags,
+                              int connection_id, void *userdata)
+{
+	const unsigned char *p;
+	zoitechat_hook *hook;
+	if (flags != 0 || connection_id < -1 || !name || !name[0] || strlen (name) > 200 ||
+		strcmp (name, "sasl") == 0 || strcmp (name, "sts") == 0)
+		return NULL; /* authentication and transport policy belong to core */
+	for (p = (const unsigned char *)name; *p; p++)
+		if (!g_ascii_islower (*p) && !g_ascii_isdigit (*p) &&
+			*p != '-' && *p != '.' && *p != '/' && *p != '_')
+			return NULL;
+	hook = plugin_add_hook (ph, HOOK_CAPABILITY, 0, name, NULL, NULL, 0, userdata);
+	hook->cap_connection_id = connection_id;
+	return hook;
+}
+
+gboolean
+plugin_requests_capability (server *serv, const char *name)
+{
+	GSList *entry;
+	for (entry = hook_list; entry; entry = entry->next)
+	{
+		zoitechat_hook *hook = entry->data;
+		if (hook && hook->type == HOOK_CAPABILITY &&
+			(hook->cap_connection_id == -1 || hook->cap_connection_id == serv->id) &&
+			strcmp (hook->name, name) == 0)
+			return TRUE;
+	}
+	return FALSE;
+}
+
 zoitechat_hook *
 zoitechat_hook_command (zoitechat_plugin *ph, const char *name, int pri,
 						  zoitechat_cmd_cb *callb, const char *help_text, void *userdata)
@@ -1181,6 +1309,25 @@ zoitechat_get_info (zoitechat_plugin *ph, const char *id)
 		return text_find_format_string (e);
 	}
 
+	/* Report the comparison actually used by this connection, not an
+	 * advertised mapping that the current core does not implement. */
+	if (strcmp (id, "casemapping") == 0)
+	{
+		if (!is_session (ph->context))
+			return NULL;
+		return ph->context->server->p_cmp == g_ascii_strcasecmp
+			? "ascii" : "rfc1459";
+	}
+
+	if (strcmp (id, "api_hook_print_after") == 0)
+		return "1";
+
+	if (strcmp (id, "api_context_filters") == 0)
+		return "1";
+
+	if (strcmp (id, "api_plugin_caps") == 0)
+		return "1";
+
 	hash = str_hash (id);
 	/* do the session independant ones first */
 	switch (hash)

src/common/plugin.h

@@ -150,6 +150,15 @@ struct _zoitechat_plugin
 	void (*zoitechat_event_attrs_free) (zoitechat_plugin *ph,
 									  zoitechat_event_attrs *attrs);
 
+	/* Additive API slots: append only; old binary offsets are unchanged. */
+	zoitechat_hook *(*zoitechat_hook_print_after) (zoitechat_plugin *, const char *, int,
+		int, int (*)(char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_hook_server_filtered) (zoitechat_plugin *, const char *, int,
+		int, int, const char *, int (*)(char *[], char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_hook_print_filtered) (zoitechat_plugin *, const char *, int,
+		int, int, const char *, int (*)(char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_register_capability) (zoitechat_plugin *, const char *, int, int, void *);
+
 	/* PRIVATE FIELDS! */
 	void *handle;		/* from dlopen */
 	char *filename;	/* loaded from */
@@ -174,6 +183,8 @@ int plugin_emit_command (session *sess, char *name, char *word[], char *word_eol
 int plugin_emit_server (session *sess, char *name, char *word[], char *word_eol[],
 						time_t server_time);
 int plugin_emit_print (session *sess, char *word[], time_t server_time);
+gboolean plugin_requests_capability (server *serv, const char *name);
+void plugin_emit_print_after (session *sess, char *word[], time_t server_time);
 int plugin_emit_dummy_print (session *sess, char *name);
 int plugin_emit_keypress (session *sess, unsigned int state, unsigned int keyval, gunichar key);
 GList* plugin_command_list(GList *tmp_list);

src/common/text.c

@@ -2306,6 +2306,7 @@ text_emit (int index, session *sess, char *a, char *b, char *c, char *d,
 	if (!prefs.hex_away_omit_alerts || !sess->server->is_away)
 		sound_play_event (index);
 	display_event (sess, index, word, stripcolor_args, timestamp);
+	plugin_emit_print_after (sess, word, timestamp);
 }
 
 char *

src/common/zoitechat-plugin.h

@@ -193,10 +193,39 @@ struct _zoitechat_plugin
 	zoitechat_event_attrs *(*zoitechat_event_attrs_create) (zoitechat_plugin *ph);
 	void (*zoitechat_event_attrs_free) (zoitechat_plugin *ph,
 									  zoitechat_event_attrs *attrs);
+	/* Additive API slots: append only; old binary offsets are unchanged. */
+	zoitechat_hook *(*zoitechat_hook_print_after) (zoitechat_plugin *, const char *, int,
+		int, int (*)(char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_hook_server_filtered) (zoitechat_plugin *, const char *, int,
+		int, int, const char *, int (*)(char *[], char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_hook_print_filtered) (zoitechat_plugin *, const char *, int,
+		int, int, const char *, int (*)(char *[], zoitechat_event_attrs *, void *), void *);
+	zoitechat_hook *(*zoitechat_register_capability) (zoitechat_plugin *, const char *, int, int, void *);
+
 };
 #endif
 
 
+/* api_hook_print_after=1: observer returns are ignored; flags must be zero. */
+zoitechat_hook *zoitechat_hook_print_after (zoitechat_plugin *ph,
+    const char *name, int pri, int flags,
+    int (*callback) (char *word[], zoitechat_event_attrs *attrs, void *userdata),
+    void *userdata);
+
+/* api_context_filters=1: connection_id -1 is any; NULL channel is any. */
+zoitechat_hook *zoitechat_hook_server_filtered (zoitechat_plugin *ph,
+    const char *name, int pri, int flags, int connection_id, const char *channel,
+    int (*callback) (char *word[], char *word_eol[], zoitechat_event_attrs *attrs, void *userdata),
+    void *userdata);
+zoitechat_hook *zoitechat_hook_print_filtered (zoitechat_plugin *ph,
+    const char *name, int pri, int flags, int connection_id, const char *channel,
+    int (*callback) (char *word[], zoitechat_event_attrs *attrs, void *userdata),
+    void *userdata);
+
+/* api_plugin_caps=1: register before CAP LS; flags=0, connection_id=-1 for any. */
+zoitechat_hook *zoitechat_register_capability (zoitechat_plugin *ph,
+    const char *name, int flags, int connection_id, void *userdata);
+
 zoitechat_hook *
 zoitechat_hook_command (zoitechat_plugin *ph,
 		    const char *name,
@@ -416,6 +445,10 @@ zoitechat_pluginpref_list (zoitechat_plugin *ph,
 #define zoitechat_hook_server ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_server)
 #define zoitechat_hook_server_attrs ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_server_attrs)
 #define zoitechat_hook_print ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_print)
+#define zoitechat_register_capability ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_register_capability)
+#define zoitechat_hook_server_filtered ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_server_filtered)
+#define zoitechat_hook_print_filtered ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_print_filtered)
+#define zoitechat_hook_print_after ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_print_after)
 #define zoitechat_hook_print_attrs ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_print_attrs)
 #define zoitechat_hook_timer ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_timer)
 #define zoitechat_hook_fd ((ZOITECHAT_PLUGIN_HANDLE)->zoitechat_hook_fd)

src/common/zoitechat.c

@@ -95,6 +95,7 @@ int zoitechat_is_quitting = FALSE;
 /* command-line args */
 int arg_dont_autoconnect = FALSE;
 int arg_skip_plugins = FALSE;
+gint arg_run_as_root = FALSE;
 char *arg_url = NULL;
 char **arg_urls = NULL;
 char *arg_command = NULL;
@@ -1175,6 +1176,25 @@ main (int argc, char *argv[])
 	HRESULT coinit_result;
 #endif
 
+#ifdef __linux__
+	for (i = 1; i < argc; i++)
+	{
+		if (strcmp (argv[i], "--") == 0)
+			break;
+		if (strcmp (argv[i], "--run-as-root") == 0)
+		{
+			arg_run_as_root = TRUE;
+			break;
+		}
+	}
+
+	if (geteuid () == 0 && !arg_run_as_root)
+	{
+		fe_root_warning ();
+		return EXIT_FAILURE;
+	}
+#endif
+
 	srand ((unsigned int) time (NULL)); /* CL: do this only once! */
 
 	/* We must check for the config dir parameter, otherwise load_config() will behave incorrectly.
@@ -1263,7 +1283,7 @@ main (int argc, char *argv[])
 #ifndef WIN32
 #ifndef __EMX__
 	/* OS/2 uses UID 0 all the time */
-	if (getuid () == 0)
+	if (getuid () == 0 && !arg_run_as_root)
 		fe_message (_("* Running IRC as root is stupid! You should\n"
 			      "  create a User Account and use that to login.\n"), FE_MSG_WARN|FE_MSG_WAIT);
 #endif

src/common/zoitechat.h

@@ -450,6 +450,7 @@ typedef struct session
 	int mode_timeout_tag;
 	int typing_timeout_tag;
 	int typing_status;
+	gint64 typing_last_sent;
 	int typing_animation_tag;
 	int typing_animation_frame;
 

src/common/zoitechatc.h

@@ -25,6 +25,7 @@ extern struct zoitechatprefs prefs;
 extern int zoitechat_is_quitting;
 extern gint arg_skip_plugins;	/* command-line args */
 extern gint arg_dont_autoconnect;
+extern gint arg_run_as_root;
 extern char *arg_url;
 extern char **arg_urls;
 extern char *arg_command;

src/fe-gtk/ascii.c

@@ -138,7 +138,7 @@ ascii_open (void)
 		{
 			table_pos++;
 			hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
-			gtk_container_add (GTK_CONTAINER (vbox), hbox);
+			gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
 			gtk_widget_show (hbox);
 			i++;
 			continue;
@@ -155,14 +155,14 @@ ascii_open (void)
 								G_CALLBACK (ascii_click), NULL);
 		g_signal_connect (G_OBJECT (but), "enter-notify-event",
 								G_CALLBACK (ascii_enter), label);
-		gtk_box_pack_start (GTK_BOX (hbox), but, 0, 0, 0);
+		gtk_box_pack_start (GTK_BOX (hbox), but, TRUE, TRUE, 0);
 		gtk_widget_show (but);
 
 		table_pos += len;
 	}
 
 	frame = gtk_frame_new ("");
-	gtk_container_add (GTK_CONTAINER (hbox), frame);
+	gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
 	gtk_container_add (GTK_CONTAINER (frame), label);
 	gtk_widget_show (label);
 	gtk_widget_show (frame);

src/fe-gtk/fe-gtk.c

@@ -90,6 +90,9 @@ static const GOptionEntry gopt_entries[] =
  {"no-auto",	'a', 0, G_OPTION_ARG_NONE,	&arg_dont_autoconnect, N_("Don't auto connect to servers"), NULL},
  {"cfgdir",	'd', 0, G_OPTION_ARG_STRING,	&arg_cfgdir, N_("Use a different config directory"), "PATH"},
  {"no-plugins",	'n', 0, G_OPTION_ARG_NONE,	&arg_skip_plugins, N_("Don't auto load any plugins"), NULL},
+#ifdef __linux__
+ {"run-as-root", 0, 0, G_OPTION_ARG_NONE, &arg_run_as_root, N_("Allow ZoiteChat to run as root (unsafe)"), NULL},
+#endif
  {"plugindir",	'p', 0, G_OPTION_ARG_NONE,	&arg_show_autoload, N_("Show plugin/script auto-load directory"), NULL},
  {"configdir",	'u', 0, G_OPTION_ARG_NONE,	&arg_show_config, N_("Show user config directory"), NULL},
  {"url",	 0,  G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_STRING, &arg_url, N_("Open an irc://server:port/channel?key URL"), "URL"},
@@ -103,6 +106,33 @@ static const GOptionEntry gopt_entries[] =
  {NULL}
 };
 
+#ifdef __linux__
+void
+fe_root_warning (void)
+{
+	const char *message =
+		"ZoiteChat refuses to run as root on Linux.\n\n"
+		"Run it as a normal user, or pass --run-as-root to override this protection.";
+	GtkWidget *dialog;
+
+	g_printerr ("%s\n", message);
+
+	/* A graphical session may not be accessible to root, particularly under
+	 * Wayland. Keep stderr as the fallback if GTK cannot open the display. */
+	if (!gtk_init_check (NULL, NULL))
+		return;
+
+	dialog = gtk_message_dialog_new (NULL,
+	                                 GTK_DIALOG_MODAL,
+	                                 GTK_MESSAGE_ERROR,
+	                                 GTK_BUTTONS_CLOSE,
+	                                 "%s", message);
+	gtk_window_set_title (GTK_WINDOW (dialog), "ZoiteChat");
+	gtk_dialog_run (GTK_DIALOG (dialog));
+	gtk_widget_destroy (dialog);
+}
+#endif
+
 #ifdef WIN32
 static void
 create_msg_dialog (gchar *title, gchar *message)

src/fe-gtk/fkeys.c

@@ -1221,7 +1221,7 @@ key_dialog_load (GtkListStore *store)
 void
 key_dialog_show ()
 {
-	GtkWidget *vbox, *box;
+	GtkWidget *vbox, *box, *pane, *scroll;
 	GtkWidget *view, *xtext, *delete_button;
 	GtkListStore *store;
 	XTextColor xtext_palette[XTEXT_COLS];
@@ -1237,10 +1237,20 @@ key_dialog_show ()
 	key_dialog = mg_create_generic_tab ("editkeys", buf, TRUE, FALSE, key_dialog_close,
 									NULL, 600, 360, &vbox, 0);
 
-	view = key_dialog_treeview_new (vbox);
+	pane = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
+	gtk_box_pack_start (GTK_BOX (vbox), pane, TRUE, TRUE, 0);
+	box = gtkutil_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
+	gtk_paned_pack1 (GTK_PANED (pane), box, TRUE, FALSE);
+	view = key_dialog_treeview_new (box);
+	scroll = gtk_scrolled_window_new (NULL, NULL);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
+	                                GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+	gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (scroll), 80);
+	gtk_paned_pack2 (GTK_PANED (pane), scroll, TRUE, FALSE);
+	gtk_paned_set_position (GTK_PANED (pane), 220);
 	theme_get_xtext_colors (xtext_palette, XTEXT_COLS);
 	xtext = gtk_xtext_new (xtext_palette, 0);
-	gtk_box_pack_start (GTK_BOX (vbox), xtext, FALSE, TRUE, 2);
+	gtk_container_add (GTK_CONTAINER (scroll), xtext);
 	gtk_xtext_set_font (GTK_XTEXT (xtext), prefs.hex_text_font);
 
 	g_object_set_data (G_OBJECT (key_dialog), "view", view);

src/fe-gtk/gtkutil.c

@@ -641,9 +641,8 @@ gtkutil_get_str (char *msg, char *def, void *callback, void *userdata, gboolean
 	if (parent_window && GTK_IS_WINDOW (parent_window))
 		gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
 	gtkutil_place_dialog (dialog);
-	gtk_box_set_homogeneous (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), TRUE);
 
-	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, TRUE, 0);
+	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 6);
 
 	g_object_set_data (G_OBJECT (dialog), "cb", callback);
 	g_object_set_data (G_OBJECT (dialog), "ud", userdata);
@@ -653,7 +652,8 @@ gtkutil_get_str (char *msg, char *def, void *callback, void *userdata, gboolean
 						 	G_CALLBACK (gtkutil_str_enter), dialog);
 	gtk_entry_set_text (GTK_ENTRY (entry), def ? def : "");
 	gtk_entry_set_visibility (GTK_ENTRY (entry), visible);
-	gtk_box_pack_end (GTK_BOX (hbox), entry, 0, 0, 0);
+	gtk_widget_set_valign (entry, GTK_ALIGN_CENTER);
+	gtk_box_pack_end (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
 
 	label = gtk_label_new (msg);
 	gtk_box_pack_end (GTK_BOX (hbox), label, 0, 0, 0);
@@ -661,7 +661,8 @@ gtkutil_get_str (char *msg, char *def, void *callback, void *userdata, gboolean
 	g_signal_connect (G_OBJECT (dialog), "response",
 						   G_CALLBACK (gtkutil_get_str_response), entry);
 
-	gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+	                    hbox, TRUE, TRUE, 0);
 
 	gtk_widget_show_all (dialog);
 }
@@ -742,9 +743,8 @@ fe_get_int (char *msg, int def, void *callback, void *userdata)
 	if (parent_window && GTK_IS_WINDOW (parent_window))
 		gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
 	gtkutil_place_dialog (dialog);
-	gtk_box_set_homogeneous (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), TRUE);
 
-	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, TRUE, 0);
+	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 6);
 
 	g_object_set_data (G_OBJECT (dialog), "cb", callback);
 	g_object_set_data (G_OBJECT (dialog), "ud", userdata);
@@ -755,7 +755,8 @@ fe_get_int (char *msg, int def, void *callback, void *userdata)
 	gtk_adjustment_set_upper (adj, 1024);
 	gtk_adjustment_set_step_increment (adj, 1);
 	gtk_spin_button_set_value ((GtkSpinButton*)spin, def);
-	gtk_box_pack_end (GTK_BOX (hbox), spin, 0, 0, 0);
+	gtk_widget_set_valign (spin, GTK_ALIGN_CENTER);
+	gtk_box_pack_end (GTK_BOX (hbox), spin, TRUE, TRUE, 0);
 
 	label = gtk_label_new (msg);
 	gtk_box_pack_end (GTK_BOX (hbox), label, 0, 0, 0);
@@ -763,7 +764,8 @@ fe_get_int (char *msg, int def, void *callback, void *userdata)
 	g_signal_connect (G_OBJECT (dialog), "response",
 						   G_CALLBACK (gtkutil_get_number_response), spin);
 
-	gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+	                    hbox, TRUE, TRUE, 0);
 
 	gtk_widget_show_all (dialog);
 }
@@ -783,17 +785,18 @@ fe_get_bool (char *title, char *prompt, void *callback, void *userdata)
 	if (parent_window && GTK_IS_WINDOW (parent_window))
 		gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
 	gtkutil_place_dialog (dialog);
-	gtk_box_set_homogeneous (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), TRUE);
 
 	g_object_set_data (G_OBJECT (dialog), "cb", callback);
 	g_object_set_data (G_OBJECT (dialog), "ud", userdata);
 
 	prompt_label = gtk_label_new (prompt);
+	gtk_label_set_line_wrap (GTK_LABEL (prompt_label), TRUE);
 
 	g_signal_connect (G_OBJECT (dialog), "response",
 		G_CALLBACK (gtkutil_get_bool_response), NULL);
 
-	gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), prompt_label);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+	                    prompt_label, TRUE, TRUE, 0);
 
 	gtk_widget_show_all (dialog);
 }
@@ -885,7 +888,10 @@ gtkutil_window_new (char *title, char *role, int width, int height, int flags)
 	gtk_window_set_wmclass (GTK_WINDOW (win), "ZoiteChat", "zoitechat");
 #endif
 	gtk_window_set_title (GTK_WINDOW (win), title);
-	gtk_window_set_default_size (GTK_WINDOW (win), width, height);
+	/* Zero means content-sized to callers; GTK requires -1 for that. */
+	gtk_window_set_default_size (GTK_WINDOW (win),
+	                             width > 0 ? width : -1,
+	                             height > 0 ? height : -1);
 	gtk_window_set_role (GTK_WINDOW (win), role);
 	if (flags & 1)
 		gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_MOUSE);

src/fe-gtk/inline-image.c

@@ -1848,10 +1848,33 @@ image_viewer_button_press (GtkWidget *widget, GdkEventButton *event,
 	return TRUE;
 }
 
+static gboolean
+image_viewer_draw (GtkWidget *widget, cairo_t *cr, gpointer data)
+{
+	GdkPixbuf *pixbuf = data;
+	int width = gdk_pixbuf_get_width (pixbuf);
+	int height = gdk_pixbuf_get_height (pixbuf);
+	int available_width = gtk_widget_get_allocated_width (widget);
+	int available_height = gtk_widget_get_allocated_height (widget);
+	double scale = MIN ((double) available_width / width,
+	                    (double) available_height / height);
+
+	/* Draw from the original so repeated resizing never degrades the image. */
+	cairo_save (cr);
+	cairo_translate (cr, (available_width - width * scale) / 2,
+	                 (available_height - height * scale) / 2);
+	cairo_scale (cr, scale, scale);
+	gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
+	cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_BILINEAR);
+	cairo_paint (cr);
+	cairo_restore (cr);
+	return FALSE;
+}
+
 void
 inline_image_show_viewer (GtkXText *xtext, textentry *ent)
 {
-	GdkPixbuf *pixbuf, *scaled = NULL;
+	GdkPixbuf *pixbuf;
 	GtkWidget *window, *eventbox, *image, *toplevel;
 	const char *url;
 	int width, height, max_width = 1280, max_height = 960;
@@ -1885,18 +1908,15 @@ inline_image_show_viewer (GtkXText *xtext, textentry *ent)
 		double scale = MIN ((double) max_width / width,
 								  (double) max_height / height);
 
-		scaled = gdk_pixbuf_scale_simple (pixbuf,
-			MAX (1, (int) (width * scale)), MAX (1, (int) (height * scale)),
-			GDK_INTERP_BILINEAR);
-		if (scaled)
-			pixbuf = scaled;
+		width = MAX (1, (int) (width * scale));
+		height = MAX (1, (int) (height * scale));
 	}
 
 	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 	url = gtk_xtext_entry_get_image_url (xtext, ent);
 	gtk_window_set_title (GTK_WINDOW (window), url ? url : _("Image"));
 	gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
-	gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+	gtk_window_set_default_size (GTK_WINDOW (window), width, height);
 
 	toplevel = gtk_widget_get_toplevel (GTK_WIDGET (xtext));
 	if (GTK_IS_WINDOW (toplevel))
@@ -1908,7 +1928,10 @@ inline_image_show_viewer (GtkXText *xtext, textentry *ent)
 	}
 
 	eventbox = gtk_event_box_new ();
-	image = gtk_image_new_from_pixbuf (pixbuf);
+	image = gtk_drawing_area_new ();
+	g_object_set_data_full (G_OBJECT (image), "zoitechat-viewer-image",
+	                        g_object_ref (pixbuf), g_object_unref);
+	g_signal_connect (G_OBJECT (image), "draw", G_CALLBACK (image_viewer_draw), pixbuf);
 	gtk_container_add (GTK_CONTAINER (eventbox), image);
 	gtk_container_add (GTK_CONTAINER (window), eventbox);
 
@@ -1918,7 +1941,4 @@ inline_image_show_viewer (GtkXText *xtext, textentry *ent)
 							G_CALLBACK (image_viewer_button_press), window);
 
 	gtk_widget_show_all (window);
-
-	if (scaled)
-		g_object_unref (scaled);
 }

src/fe-gtk/joind.c

@@ -137,7 +137,6 @@ joind_show_dialog (server *serv)
 	gtk_window_set_position (GTK_WINDOW (dialog1), GTK_WIN_POS_CENTER_ON_PARENT);
 	gtk_window_set_transient_for (GTK_WINDOW(dialog1), GTK_WINDOW(serv->front_session->gui->window));
 	gtk_window_set_modal (GTK_WINDOW (dialog1), TRUE);
-	gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE);
 
 	dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (dialog1));
 	gtk_widget_show (dialog_vbox1);

src/fe-gtk/maingui.c

@@ -778,10 +778,13 @@ mg_inputbox_focus (GtkWidget *widget, GdkEventFocus *event, session_gui *gui)
 }
 
 
+#define TYPING_THROTTLE_USEC (3 * G_USEC_PER_SEC)
+
 static gboolean
 mg_client_tag_allowed (server *serv, const char *tag)
 {
         char **deny;
+        gboolean blocked = FALSE;
         int i;
 
         if (!serv->have_message_tags)
@@ -793,30 +796,42 @@ mg_client_tag_allowed (server *serv, const char *tag)
         deny = g_strsplit (serv->clienttagdeny, ",", 0);
         for (i = 0; deny[i]; i++)
         {
-                if (!strcmp (deny[i], "*") || !strcmp (deny[i], tag) || (deny[i][0] == '+' && !strcmp (deny[i] + 1, tag)))
+                if (!strcmp (deny[i], "*"))
+                        blocked = TRUE;
+                else if (deny[i][0] == '-' && !strcmp (deny[i] + 1, tag))
+                        blocked = FALSE;
+                else if (!strcmp (deny[i], tag) || (deny[i][0] == '+' && !strcmp (deny[i] + 1, tag)))
+                        blocked = TRUE;
+        }
+
+        g_strfreev (deny);
+        return !blocked;
+}
+
+static gboolean
+mg_typing_can_send (session *sess)
 {
-                        g_strfreev (deny);
-                        return FALSE;
-                }
+        gint64 now = g_get_monotonic_time ();
+
+        return sess->typing_last_sent == 0 ||
+               now - sess->typing_last_sent >= TYPING_THROTTLE_USEC;
 }
 
-        g_strfreev (deny);
-        return TRUE;
-}
-
-static void
+static gboolean
 mg_send_typing (session *sess, const char *state)
 {
         char tags[32];
 
         if (!sess || !sess->server->connected || !mg_client_tag_allowed (sess->server, "typing") || !sess->channel[0])
-                return;
+                return FALSE;
 
         if (sess->type != SESS_CHANNEL && sess->type != SESS_DIALOG)
-                return;
+                return FALSE;
 
         g_snprintf (tags, sizeof (tags), "+typing=%s", state);
         sess->server->p_tagmsg (sess->server, tags, sess->channel);
+        sess->typing_last_sent = g_get_monotonic_time ();
+        return TRUE;
 }
 
 static int
@@ -845,17 +860,15 @@ mg_typing_update (session *sess, const char *text)
 
         if (!text || !*text || text[0] == prefs.hex_input_command_char[0])
         {
-                if (sess->typing_status)
+                if (sess->typing_status && mg_typing_can_send (sess))
                         mg_send_typing (sess, "done");
                 sess->typing_status = 0;
                 return;
         }
 
-        if (sess->typing_status != 1)
-        {
+        if (mg_typing_can_send (sess))
                 mg_send_typing (sess, "active");
         sess->typing_status = 1;
-        }
         sess->typing_timeout_tag = fe_timeout_add_seconds (6, mg_typing_pause_cb, sess);
 }
 
@@ -2317,7 +2330,6 @@ mg_open_quit_dialog (gboolean minimize_button)
         gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
         gtk_window_set_title (GTK_WINDOW (dialog), _("Quit ZoiteChat?"));
         gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
-        gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
 
         dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
         gtk_widget_show (dialog_vbox1);

src/fe-gtk/menu.c

@@ -1595,16 +1595,16 @@ menu_join (GtkWidget * wid, gpointer none)
 									NULL);
 	theme_manager_attach_window (dialog);
 	content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
-	gtk_box_set_homogeneous (GTK_BOX (content_area), TRUE);
 	gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
-	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, TRUE, 0);
+	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 6);
 
 	entry = gtk_entry_new ();
 	gtk_editable_set_editable (GTK_EDITABLE (entry), FALSE);	/* avoid auto-selection */
 	gtk_entry_set_text (GTK_ENTRY (entry), "#");
 	g_signal_connect (G_OBJECT (entry), "activate",
 						 	G_CALLBACK (menu_join_entry_cb), dialog);
-	gtk_box_pack_end (GTK_BOX (hbox), entry, 0, 0, 0);
+	gtk_widget_set_valign (entry, GTK_ALIGN_CENTER);
+	gtk_box_pack_end (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
 
 	label = gtk_label_new (_("Enter Channel to Join:"));
 	gtk_box_pack_end (GTK_BOX (hbox), label, 0, 0, 0);
@@ -1612,7 +1612,7 @@ menu_join (GtkWidget * wid, gpointer none)
 	g_signal_connect (G_OBJECT (dialog), "response",
 						   G_CALLBACK (menu_join_cb), entry);
 
-	gtk_container_add (GTK_CONTAINER (content_area), hbox);
+	gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
 
 	gtk_widget_show_all (dialog);
 

src/fe-gtk/notifygui.c

@@ -391,34 +391,39 @@ fe_notify_ask (char *nick, char *networks)
 	gtk_container_set_border_width (GTK_CONTAINER (table), 12);
 	gtk_grid_set_row_spacing (GTK_GRID (table), 3);
 	gtk_grid_set_column_spacing (GTK_GRID (table), 8);
-	gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), table);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+	                    table, TRUE, TRUE, 0);
 
 	label = gtk_label_new (msg);
-	gtkutil_grid_attach_defaults (table, label, 0, 1, 0, 1);
+	gtk_label_set_xalign (GTK_LABEL (label), 0.0f);
+	gtkutil_grid_attach (table, label, 0, 1, 0, 1, GTKUTIL_ATTACH_FILL, 0, 0, 0);
 
 	entry = gtk_entry_new ();
 	gtk_entry_set_text (GTK_ENTRY (entry), nick);
 	g_signal_connect (G_OBJECT (entry), "activate",
 						 	G_CALLBACK (notifygui_add_enter), dialog);
-	gtkutil_grid_attach_defaults (table, entry, 1, 2, 0, 1);
+	gtkutil_grid_attach (table, entry, 1, 2, 0, 1,
+	                     GTKUTIL_ATTACH_EXPAND | GTKUTIL_ATTACH_FILL, 0, 0, 0);
 
 	g_signal_connect (G_OBJECT (dialog), "response",
 						   G_CALLBACK (notifygui_add_cb), entry);
 
 	label = gtk_label_new (_("Notify on these networks:"));
-	gtkutil_grid_attach_defaults (table, label, 0, 1, 2, 3);
+	gtk_label_set_xalign (GTK_LABEL (label), 0.0f);
+	gtkutil_grid_attach (table, label, 0, 1, 2, 3, GTKUTIL_ATTACH_FILL, 0, 0, 0);
 
 	wid = gtk_entry_new ();
 	g_object_set_data (G_OBJECT (entry), "net", wid);
 	g_signal_connect (G_OBJECT (wid), "activate",
 						 	G_CALLBACK (notifygui_add_enter), dialog);
 	gtk_entry_set_text (GTK_ENTRY (wid), networks ? networks : "ALL");
-	gtkutil_grid_attach_defaults (table, wid, 1, 2, 2, 3);
+	gtkutil_grid_attach (table, wid, 1, 2, 2, 3,
+	                     GTKUTIL_ATTACH_EXPAND | GTKUTIL_ATTACH_FILL, 0, 0, 0);
 
 	label = gtk_label_new (NULL);
 	g_snprintf (buf, sizeof (buf), "<i><span size=\"smaller\">%s</span></i>", _("Comma separated list of networks is accepted."));
 	gtk_label_set_markup (GTK_LABEL (label), buf);
-	gtkutil_grid_attach_defaults (table, label, 1, 2, 3, 4);
+	gtkutil_grid_attach (table, label, 1, 2, 3, 4, GTKUTIL_ATTACH_FILL, 0, 0, 0);
 
 	gtk_widget_show_all (dialog);
 }

src/fe-gtk/servlistgui.c

@@ -2423,6 +2423,8 @@ servlist_open_edit (GtkWidget *parent, ircnet *net)
 	GtkWidget *comboboxentry_charset;
 	GtkWidget *combobox_logintypes;
 	GtkWidget *hbox1;
+	GtkWidget *content_scroll;
+	GtkWidget *content_box;
 	GtkWidget *scrolledwindow2;
 	GtkWidget *scrolledwindow4;
 	GtkWidget *scrolledwindow5;
@@ -2449,7 +2451,9 @@ servlist_open_edit (GtkWidget *parent, ircnet *net)
 	gtk_container_set_border_width (GTK_CONTAINER (editwindow), 4);
 	g_snprintf (buf, sizeof (buf), _("Edit %s - %s"), net->name, _(DISPLAY_NAME));
 	gtk_window_set_title (GTK_WINDOW (editwindow), buf);
-	gtk_window_set_default_size (GTK_WINDOW (editwindow), netedit_win_width, netedit_win_height);
+	gtk_window_set_default_size (GTK_WINDOW (editwindow),
+	                             netedit_win_width > 0 ? netedit_win_width : -1,
+	                             netedit_win_height > 0 ? netedit_win_height : -1);
 	gtk_window_set_transient_for (GTK_WINDOW (editwindow), GTK_WINDOW (parent));
 	gtk_window_set_modal (GTK_WINDOW (editwindow), TRUE);
 	gtk_window_set_type_hint (GTK_WINDOW (editwindow), GDK_WINDOW_TYPE_HINT_DIALOG);
@@ -2458,10 +2462,20 @@ servlist_open_edit (GtkWidget *parent, ircnet *net)
 	vbox5 = gtkutil_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
 	gtk_container_add (GTK_CONTAINER (editwindow), vbox5);
 
+	/* Keep Close accessible on small screens, while the lists still receive
+	   all spare space when the complete form fits in the window. */
+	content_scroll = gtk_scrolled_window_new (NULL, NULL);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (content_scroll),
+	                                GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+	gtk_scrolled_window_set_propagate_natural_width (GTK_SCROLLED_WINDOW (content_scroll), TRUE);
+	gtk_scrolled_window_set_propagate_natural_height (GTK_SCROLLED_WINDOW (content_scroll), TRUE);
+	gtk_box_pack_start (GTK_BOX (vbox5), content_scroll, TRUE, TRUE, 0);
+	content_box = gtkutil_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
+	gtk_container_add (GTK_CONTAINER (content_scroll), content_box);
 
 	/* Tabs and buttons */
 	hbox1 = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 0);
-	gtk_box_pack_start (GTK_BOX (vbox5), hbox1, TRUE, TRUE, 4);
+	gtk_box_pack_start (GTK_BOX (content_box), hbox1, TRUE, TRUE, 4);
 
 	scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
 	scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL);
@@ -2599,7 +2613,7 @@ servlist_open_edit (GtkWidget *parent, ircnet *net)
 
 	/* Checkboxes and entries */
 	table3 = gtkutil_grid_new (19, 2, FALSE);
-	gtk_box_pack_start (GTK_BOX (vbox5), table3, FALSE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (content_box), table3, FALSE, FALSE, 0);
 	gtk_grid_set_row_spacing (GTK_GRID (table3), 2);
 	gtk_grid_set_column_spacing (GTK_GRID (table3), 8);
 
@@ -2828,7 +2842,9 @@ servlist_open_networks (void)
 	gtk_container_set_border_width (GTK_CONTAINER (servlist), 4);
 	g_snprintf(buf, sizeof(buf), _("Network List - %s"), _(DISPLAY_NAME));
 	gtk_window_set_title (GTK_WINDOW (servlist), buf);
-	gtk_window_set_default_size (GTK_WINDOW (servlist), netlist_win_width, netlist_win_height);
+	gtk_window_set_default_size (GTK_WINDOW (servlist),
+	                             netlist_win_width > 0 ? netlist_win_width : -1,
+	                             netlist_win_height > 0 ? netlist_win_height : -1);
 	gtk_window_set_role (GTK_WINDOW (servlist), "servlist");
 	gtk_window_set_type_hint (GTK_WINDOW (servlist), GDK_WINDOW_TYPE_HINT_DIALOG);
 	if (current_sess)

src/fe-gtk/setup.c

@@ -1256,7 +1256,7 @@ setup_create_id_menu (GtkWidget *table, char *label, int row, char *dest)
 static void
 setup_create_menu (GtkWidget *table, int row, const setting *set)
 {
-        GtkWidget *wid, *cbox, *box;
+        GtkWidget *wid, *cbox;
         const char **text = (const char **)set->list;
         int i;
 
@@ -1277,9 +1277,7 @@ setup_create_menu (GtkWidget *table, int row, const setting *set)
         g_signal_connect (G_OBJECT (cbox), "changed",
                                                         G_CALLBACK (setup_menu_cb), (gpointer)set);
 
-        box = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 0);
-        gtk_box_pack_start (GTK_BOX (box), cbox, 0, 0, 0);
-        setup_table_attach (table, box, 3, 4, row, row + 1, TRUE, FALSE,
+        setup_table_attach (table, cbox, 3, 6, row, row + 1, TRUE, FALSE,
                             SETUP_ALIGN_FILL, SETUP_ALIGN_FILL, 0, 0);
 }
 
@@ -1963,7 +1961,8 @@ setup_add_page (const char *title, GtkWidget *book, GtkWidget *tab)
 
         sw = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new (NULL, NULL));
         gtk_scrolled_window_set_shadow_type (sw, GTK_SHADOW_IN);
-        gtk_scrolled_window_set_policy (sw, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+        gtk_scrolled_window_set_policy (sw, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+        gtk_scrolled_window_set_propagate_natural_width (sw, TRUE);
         gtk_container_add (GTK_CONTAINER (sw), vvbox);
 
         viewport = gtk_bin_get_child (GTK_BIN(sw));
@@ -2007,7 +2006,9 @@ setup_ensure_page_created (int page)
         }
 
         page_widget = setup_page_factories[page] (setup_page_settings[page]);
-        gtk_container_add (GTK_CONTAINER (container), page_widget);
+        /* Lazy pages must pass the notebook's spare space to their content,
+           particularly the independently scrolling Sounds list. */
+        gtk_box_pack_start (GTK_BOX (container), page_widget, TRUE, TRUE, 0);
         gtk_widget_show_all (container);
 }
 
@@ -2185,9 +2186,14 @@ setup_create_tree (GtkWidget *box, GtkWidget *book)
                                                             -1, _("Categories"), renderer, "text", 0, NULL);
         gtk_tree_view_expand_all (GTK_TREE_VIEW (tree));
 
-        frame = gtk_frame_new (NULL);
+        frame = gtk_scrolled_window_new (NULL, NULL);
+        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (frame),
+                                       GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (frame), GTK_SHADOW_IN);
+        gtk_scrolled_window_set_propagate_natural_width (GTK_SCROLLED_WINDOW (frame), TRUE);
+        gtk_widget_set_vexpand (frame, TRUE);
         gtk_container_add (GTK_CONTAINER (frame), tree);
-        gtk_box_pack_start (GTK_BOX (box), frame, 0, 0, 0);
+        gtk_box_pack_start (GTK_BOX (box), frame, FALSE, TRUE, 0);
         gtk_box_reorder_child (GTK_BOX (box), frame, 0);
 
         if (sel_iter)

src/fe-gtk/sexy-spell-entry.c

@@ -1266,8 +1266,6 @@ attr_list_has_attrs (PangoAttrList *attrs)
 static void
 sexy_spell_entry_recheck_all(SexySpellEntry *entry)
 {
-	GdkRectangle rect;
-	GtkAllocation allocation;
 	GtkWidget *widget = GTK_WIDGET(entry);
 	int length, i, text_len;
 	const char *text;
@@ -1299,15 +1297,8 @@ sexy_spell_entry_recheck_all(SexySpellEntry *entry)
 
 	gtk_entry_set_attributes (GTK_ENTRY (entry), attr_list_has_attrs (entry->priv->attr_list) ? entry->priv->attr_list : NULL);
 
-	if (gtk_widget_get_realized (GTK_WIDGET(entry)))
-	{
-		gtk_widget_get_allocation (GTK_WIDGET(entry), &allocation);
-		
-		rect.x = 0; rect.y = 0;
-		rect.width  = allocation.width;
-		rect.height = allocation.height;
-		gdk_window_invalidate_rect(gtk_widget_get_window (widget), &rect, TRUE);
-	}
+	/* GtkEntry shares its parent's GdkWindow in GTK3; redraw the widget area. */
+	gtk_widget_queue_draw (widget);
 }
 
 static gboolean

src/fe-gtk/textgui.c

@@ -400,7 +400,6 @@ pevent_treeview_new (GtkWidget *box)
 	scroll = gtk_scrolled_window_new (NULL, NULL);
 	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
-	gtk_widget_set_size_request (GTK_WIDGET (scroll), -1, 250);
 
 	store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
 	g_return_val_if_fail (store != NULL, NULL);
@@ -437,7 +436,7 @@ pevent_treeview_new (GtkWidget *box)
 	gtk_tree_view_column_set_min_width (col, 100);
 
 	gtk_container_add (GTK_CONTAINER (scroll), view);
-	gtk_container_add (GTK_CONTAINER (box), scroll);
+	gtk_paned_pack1 (GTK_PANED (box), scroll, TRUE, FALSE);
 
 	return view;
 }
@@ -481,7 +480,7 @@ pevent_hlist_treeview_new (GtkWidget *box)
 	gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 
 	gtk_container_add (GTK_CONTAINER (scroll), view);
-	gtk_container_add (GTK_CONTAINER (box), scroll);
+	gtk_paned_pack2 (GTK_PANED (box), scroll, TRUE, FALSE);
 
 	return view;
 }
@@ -489,7 +488,7 @@ pevent_hlist_treeview_new (GtkWidget *box)
 void
 pevent_dialog_show ()
 {
-	GtkWidget *vbox, *hbox, *wid, *pane;
+	GtkWidget *vbox, *hbox, *wid, *pane, *preview_pane;
 	XTextColor xtext_palette[XTEXT_COLS];
 
 	if (pevent_dialog)
@@ -503,8 +502,12 @@ pevent_dialog_show ()
 											 TRUE, FALSE, pevent_dialog_close, NULL,
 											 600, 455, &vbox, 0);
 
+	preview_pane = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
+	gtk_box_pack_start (GTK_BOX (vbox), preview_pane, TRUE, TRUE, 0);
 	pane = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
-	gtk_box_pack_start (GTK_BOX (vbox), pane, TRUE, TRUE, 0);
+	gtk_paned_pack1 (GTK_PANED (preview_pane), pane, TRUE, FALSE);
+	gtk_paned_set_position (GTK_PANED (pane), 220);
+	gtk_paned_set_position (GTK_PANED (preview_pane), 330);
 	
 	pevent_dialog_list = pevent_treeview_new (pane);
 	pevent_dialog_fill (pevent_dialog_list);
@@ -513,12 +516,12 @@ pevent_dialog_show ()
 
 	wid = gtk_scrolled_window_new (NULL, NULL);
 	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (wid), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
-	gtk_box_pack_start (GTK_BOX (vbox), wid, FALSE, TRUE, 0);
+	gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (wid), 75);
+	gtk_paned_pack2 (GTK_PANED (preview_pane), wid, TRUE, FALSE);
 
 	theme_get_xtext_colors_for_widget (wid, xtext_palette, XTEXT_COLS);
 	pevent_dialog_twid = gtk_xtext_new (xtext_palette, 0);
 	gtk_widget_set_sensitive (pevent_dialog_twid, FALSE);
-	gtk_widget_set_size_request (pevent_dialog_twid, -1, 75);
 	gtk_container_add (GTK_CONTAINER (wid), pevent_dialog_twid);
 	gtk_xtext_set_font (GTK_XTEXT (pevent_dialog_twid), prefs.hex_text_font);
 	g_object_set_data (G_OBJECT (pevent_dialog), "xtext", pevent_dialog_twid);

src/fe-gtk/theme/theme-preferences.c

@@ -1911,6 +1911,7 @@ theme_preferences_create_page (GtkWindow *parent,
                                          G_TYPE_STRING,
                                          G_TYPE_INT);
         ui->gtk3_combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (gtk3_store));
+        gtk_widget_set_hexpand (ui->gtk3_combo, TRUE);
         g_object_unref (gtk3_store);
         renderer = gtk_cell_renderer_text_new ();
         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->gtk3_combo), renderer, TRUE);

src/fe-gtk/xtext.c

@@ -273,6 +273,8 @@ static void gtk_xtext_render_page (GtkXText * xtext);
 static void gtk_xtext_calc_lines (xtext_buffer *buf, int);
 static gboolean gtk_xtext_is_selecting (GtkXText *xtext);
 static char *gtk_xtext_selection_get_text (GtkXText *xtext, int *len_ret);
+static void gtk_xtext_clipboard_get (GtkClipboard *, GtkSelectionData *, guint, gpointer);
+static void gtk_xtext_clipboard_clear (GtkClipboard *, gpointer);
 static textentry *gtk_xtext_nth (GtkXText *xtext, int line, int *subline);
 static void gtk_xtext_adjustment_changed (GtkAdjustment * adj,
 												GtkXText * xtext);
@@ -1082,9 +1084,29 @@ gtk_xtext_new (const XTextColor *palette, int separator)
 	return GTK_WIDGET (xtext);
 }
 
+static void
+gtk_xtext_release_selections (GtkXText *xtext)
+{
+	GdkAtom selections[] = { GDK_SELECTION_PRIMARY, GDK_SELECTION_SECONDARY };
+	guint i;
+
+	if (!gtk_widget_has_screen (GTK_WIDGET (xtext)))
+		return;
+
+	for (i = 0; i < G_N_ELEMENTS (selections); i++)
+	{
+		GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (xtext), selections[i]);
+
+		if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (xtext))
+			gtk_clipboard_clear (clipboard);
+	}
+}
+
 static void
 gtk_xtext_cleanup (GtkXText *xtext)
 {
+	gtk_xtext_release_selections (xtext);
+
 	if (xtext->add_io_tag)
 	{
 		g_source_remove (xtext->add_io_tag);
@@ -1179,6 +1201,7 @@ gtk_xtext_finalize (GObject *object)
 static void
 gtk_xtext_unrealize (GtkWidget * widget)
 {
+	gtk_xtext_release_selections (GTK_XTEXT (widget));
 	backend_deinit (GTK_XTEXT (widget));
 
 	/*
@@ -2743,8 +2766,16 @@ gtk_xtext_set_clip_owner (GtkWidget * xtext, GdkEventButton * event)
 		{
 			gtk_clipboard_set_text (gtk_widget_get_clipboard (xtext, GDK_SELECTION_CLIPBOARD), str, len);
 			
-			gtk_selection_owner_set (xtext, GDK_SELECTION_PRIMARY, event ? event->time : GDK_CURRENT_TIME);
-			gtk_selection_owner_set (xtext, GDK_SELECTION_SECONDARY, event ? event->time : GDK_CURRENT_TIME);
+			/* Let GtkClipboard own the X11 selection window. Making xtext
+			 * the selection owner forces its window native and bypasses
+			 * GTK's toplevel backing buffer on subsequent redraws.
+			 */
+			gtk_clipboard_set_with_owner (gtk_widget_get_clipboard (xtext, GDK_SELECTION_PRIMARY),
+				gtk_xtext_selection_targets, G_N_ELEMENTS (gtk_xtext_selection_targets),
+				gtk_xtext_clipboard_get, gtk_xtext_clipboard_clear, G_OBJECT (xtext));
+			gtk_clipboard_set_with_owner (gtk_widget_get_clipboard (xtext, GDK_SELECTION_SECONDARY),
+				gtk_xtext_selection_targets, G_N_ELEMENTS (gtk_xtext_selection_targets),
+				gtk_xtext_clipboard_get, gtk_xtext_clipboard_clear, G_OBJECT (xtext));
 		}
 
 		g_free (str);
@@ -3172,7 +3203,7 @@ gtk_xtext_selection_get (GtkWidget * widget,
 			if (!window || !GDK_IS_WINDOW (window))
 				break;
 			display = gdk_window_get_display (window);
-			if (!display)
+			if (!display || !GDK_IS_X11_DISPLAY (display))
 				break;
 			GdkAtom encoding;
 			gint format;
@@ -3197,6 +3228,29 @@ gtk_xtext_selection_get (GtkWidget * widget,
 	g_free (stripped);
 }
 
+static void
+gtk_xtext_clipboard_get (GtkClipboard *clipboard, GtkSelectionData *selection_data,
+						 guint info, gpointer owner)
+{
+	int len;
+	char *text = gtk_xtext_selection_get_text (GTK_XTEXT (owner), &len);
+
+	if (text)
+	{
+		gtk_selection_data_set_text (selection_data, text, len);
+		g_free (text);
+	}
+}
+
+static void
+gtk_xtext_clipboard_clear (GtkClipboard *clipboard, gpointer owner)
+{
+	GtkXText *xtext = GTK_XTEXT (owner);
+
+	if (xtext->orig_buffer)
+		gtk_xtext_selection_kill (xtext, NULL);
+}
+
 static gboolean
 gtk_xtext_scroll (GtkWidget *widget, GdkEventScroll *event)
 {

src/fe-text/fe-text.c

@@ -467,6 +467,9 @@ static const GOptionEntry gopt_entries[] =
  {"no-auto",	'a', 0, G_OPTION_ARG_NONE,	&arg_dont_autoconnect, N_("Don't auto connect to servers"), NULL},
  {"cfgdir",	'd', 0, G_OPTION_ARG_STRING,	&arg_cfgdir, N_("Use a different config directory"), "PATH"},
  {"no-plugins",	'n', 0, G_OPTION_ARG_NONE,	&arg_skip_plugins, N_("Don't auto load any plugins"), NULL},
+#ifdef __linux__
+ {"run-as-root", 0, 0, G_OPTION_ARG_NONE, &arg_run_as_root, N_("Allow ZoiteChat to run as root (unsafe)"), NULL},
+#endif
  {"plugindir",	'p', 0, G_OPTION_ARG_NONE,	&arg_show_autoload, N_("Show plugin/script auto-load directory"), NULL},
  {"configdir",	'u', 0, G_OPTION_ARG_NONE,	&arg_show_config, N_("Show user config directory"), NULL},
  {"url",	 0,  G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_STRING,	&arg_url, N_("Open an irc://server:port/channel URL"), "URL"},
@@ -475,6 +478,16 @@ static const GOptionEntry gopt_entries[] =
  {NULL}
 };
 
+#ifdef __linux__
+void
+fe_root_warning (void)
+{
+	fputs ("ZoiteChat refuses to run as root on Linux.\n"
+	       "Run it as a normal user, or pass --run-as-root to override this protection.\n",
+	       stderr);
+}
+#endif
+
 int
 fe_args (int argc, char *argv[])
 {

win32/copy/copy.vcxproj

@@ -90,6 +90,7 @@
       <MSWindowsTheme Include="$(DepsRoot)\share\themes\MS-Windows\**\*" />
       <HicolorIcons Include="$(DepsRoot)\share\icons\hicolor\index.theme" />
       <HicolorIcons Include="$(DepsRoot)\share\icons\hicolor\**\*.*" />
+      <PythonAdditiveApis Include="..\..\plugins\python\_zoitechat_*.py" />
     </ItemGroup>
 
     <Copy SourceFiles="@(None)" DestinationFolder="$(ZoiteChatRel)" />
@@ -115,6 +116,7 @@
     <Copy SourceFiles="..\..\plugins\python\hexchat.py" DestinationFolder="$(ZoiteChatRel)\python" Condition="'$(Python3Enabled)'=='true' or '$(Python38Enabled)'=='true'" />
     <Copy SourceFiles="..\..\plugins\python\zoitechat.py" DestinationFolder="$(ZoiteChatRel)\python" Condition="'$(Python3Enabled)'=='true' or '$(Python38Enabled)'=='true'" />
     <Copy SourceFiles="..\..\plugins\python\_zoitechat.py" DestinationFolder="$(ZoiteChatRel)\python" Condition="'$(Python3Enabled)'=='true' or '$(Python38Enabled)'=='true'" />
+    <Copy SourceFiles="@(PythonAdditiveApis)" DestinationFolder="$(ZoiteChatRel)\python" Condition="('$(Python3Enabled)'=='true' or '$(Python38Enabled)'=='true') and '@(PythonAdditiveApis)' != ''" />
 
     <WriteLinesToFile File="$(ZoiteChatRel)portable-mode" Lines="2" Overwrite="true" />