working on todo.md features

src/ui_widgets.cpp

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 Martino Ferrari
+//
+// The small reusable pieces of GTK chrome: a menu row and the three rows built from it, a labelled\n// panel row, the one stylesheet rule the app needs, and the modal dialog frame every dialog here is\n// built in. They know nothing about this app beyond the widget types they return.
+
+#include "ui_app.hpp"
+
+#include <gtk/gtk.h>
+
+#include <string>
+
+namespace udpscope {
+namespace ui_impl {
+
+/// Installs the one style rule the app needs: a signal row that is as short as its
+/// contents.
+///
+/// Adwaita gives a button a 34 px minimum height and a list row its own padding, and
+/// those -- not the widgets in it -- are what set a signal row's height, so no amount
+/// of trimming margins in C makes the list shorter. A handful of signals then filled
+/// the whole side panel. Scoped to `.udpscope-compact` so it cannot reach any other
+/// button in the window.
+void install_css() {
+  static const char kCss[] =
+      "row.udpscope-compact { min-height: 0; padding: 1px 0; }\n"
+      // A popover menu row: Adwaita gives a button a 34 px minimum height and 8 px of padding,
+      // which is what made the overflow read as a stack of dialogs rather than a menu. The
+      // shortcut label is a plain .dim-label at the row's right, so all that is left to trim
+      // is the row itself.
+      "popover.udpscope-menu button { min-height: 0; padding: 3px 8px; }\n"
+      "popover.udpscope-menu button > box { min-height: 0; }\n"
+      "popover.udpscope-menu button label { min-height: 0; }\n"
+      "popover.udpscope-menu image { min-width: 12px; min-height: 0; }\n"
+      "popover.udpscope-menu separator { margin: 4px 0; }\n"
+      // The events pane: the row's time is what a person scans for, so it is the one thing in the
+      // column that is not dim; the thumbnail gets an edge, or a dark plot on a dark pane has none.
+      ".udpscope-event-title { font-weight: bold; }\n"
+      ".udpscope-event-thumb { border: 1px solid alpha(currentColor, 0.15); border-radius: 4px; }\n"
+      "row.udpscope-compact button { min-height: 20px; min-width: 20px; padding: 0 3px; }\n"
+      "row.udpscope-compact checkbutton { min-height: 20px; }\n";
+  GtkCssProvider* p = gtk_css_provider_new();
+  gtk_css_provider_load_from_string(p, kCss);
+  gtk_style_context_add_provider_for_display(gdk_display_get_default(),
+                                             GTK_STYLE_PROVIDER(p),
+                                             GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+  g_object_unref(p);
+}
+
+/// Keeps a menu row's check in step with its toggle. The check keeps its allocation when it is
+/// off (opacity, not visibility), so a checked and an unchecked row's labels line up.
+void on_menu_row_toggled(GtkToggleButton* button, gpointer) {
+  GtkWidget* check = GTK_WIDGET(g_object_get_data(G_OBJECT(button), "udpscope-check"));
+  if (check != nullptr) {
+    gtk_widget_set_opacity(check, gtk_toggle_button_get_active(button) ? 1.0 : 0.0);
+  }
+}
+
+/// One row of a popover menu, laid out the way a GNOME menu lays one out: the label at the
+/// left, the shortcut at the right when the action has one, and -- for a row that toggles
+/// something -- a check in its own column. Returned as a box for the caller to hand to
+/// `gtk_button_set_child()`; `.udpscope-menu` in install_css() is what trims the height.
+GtkWidget* menu_row(const char* label, const char* accel, bool with_check,
+                    GtkWidget** out_check) {
+  GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
+  if (with_check) {
+    GtkWidget* check = gtk_image_new_from_icon_name("object-select-symbolic");
+    gtk_widget_set_opacity(check, 0.0);
+    gtk_box_append(GTK_BOX(box), check);
+    if (out_check != nullptr) *out_check = check;
+  }
+  GtkWidget* text = gtk_label_new(label);
+  gtk_label_set_xalign(GTK_LABEL(text), 0.0f);
+  gtk_widget_set_hexpand(text, true);
+  gtk_box_append(GTK_BOX(box), text);
+  if (accel != nullptr) {
+    GtkWidget* key = gtk_label_new(accel);
+    gtk_label_set_xalign(GTK_LABEL(key), 1.0f);
+    gtk_widget_add_css_class(key, "dim-label");
+    gtk_box_append(GTK_BOX(box), key);
+  }
+  return box;
+}
+
+/// A plain menu row. `accel` is what the app binds the action to (see shortcuts.cpp) -- it is
+/// shown, never bound here: the key handling stays in the one controller that refuses a key
+/// while a text field has focus.
+GtkWidget* menu_button(const char* label, const char* accel) {
+  GtkWidget* button = gtk_button_new();
+  // The check column is reserved even though this row cannot be checked: a menu whose labels
+  // start at two different x -- one for the rows that can be checked and one for the rest --
+  // is what "the text is not left-aligned" looks like.
+  gtk_button_set_child(GTK_BUTTON(button), menu_row(label, accel, true, nullptr));
+  gtk_widget_add_css_class(button, "flat");
+  gtk_widget_set_hexpand(button, true);
+  gtk_widget_set_halign(button, GTK_ALIGN_FILL);
+  return button;
+}
+
+/// A menu row that toggles something, with the check menu_row() reserves the column for. The
+/// initial state is set *before* the handler is connected: a programmatic `set_active()` emits
+/// `toggled`, the handler acts on widgets the caller has not built yet (the signal list's
+/// revealer is created later in run_ui()), and a row that is created on must not reach it.
+GtkWidget* menu_toggle(const char* label, const char* accel, bool active) {
+  GtkWidget* button = gtk_toggle_button_new();
+  GtkWidget* check = nullptr;
+  gtk_button_set_child(GTK_BUTTON(button), menu_row(label, accel, true, &check));
+  gtk_widget_add_css_class(button, "flat");
+  gtk_widget_set_hexpand(button, true);
+  gtk_widget_set_halign(button, GTK_ALIGN_FILL);
+  g_object_set_data(G_OBJECT(button), "udpscope-check", check);
+  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), active);
+  on_menu_row_toggled(GTK_TOGGLE_BUTTON(button), nullptr);
+  g_signal_connect(button, "toggled", G_CALLBACK(on_menu_row_toggled), nullptr);
+  return button;
+}
+
+GtkWidget* menu_separator() {
+  return gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
+}
+
+GtkWidget* labeled_box(const char* label, GtkWidget* child) {
+  GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
+  GtkWidget* l = gtk_label_new(label);
+  gtk_widget_set_halign(l, GTK_ALIGN_START);
+  gtk_box_append(GTK_BOX(box), l);
+  gtk_widget_set_hexpand(child, true);
+  gtk_box_append(GTK_BOX(box), child);
+  return box;
+}
+
+/// A modal, transient window with a vertical content box; the caller appends its
+/// controls and then a button row. GTK 4.10 deprecated `GtkDialog` and
+/// `GtkMessageDialog`, so the dialogs here are built from a plain window.
+GtkWidget* dialog_window(GtkWidget* parent, const char* title) {
+  GtkWidget* w = gtk_window_new();
+  gtk_window_set_title(GTK_WINDOW(w), title);
+  if (parent != nullptr) gtk_window_set_transient_for(GTK_WINDOW(w), GTK_WINDOW(parent));
+  gtk_window_set_modal(GTK_WINDOW(w), TRUE);
+  gtk_window_set_default_size(GTK_WINDOW(w), 340, -1);
+  GtkWidget* box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
+  gtk_widget_set_margin_top(box, 12);
+  gtk_widget_set_margin_bottom(box, 12);
+  gtk_widget_set_margin_start(box, 12);
+  gtk_widget_set_margin_end(box, 12);
+  gtk_window_set_child(GTK_WINDOW(w), box);
+  return w;
+}
+
+/// Appends `button` to a right-aligned row at the end of the dialog's box.
+void dialog_add_button(GtkWidget* window, GtkWidget* button) {
+  GtkWidget* box = gtk_window_get_child(GTK_WINDOW(window));
+  GtkWidget* last = gtk_widget_get_last_child(box);
+  GtkWidget* row = nullptr;
+  if (last != nullptr && g_object_get_data(G_OBJECT(last), "udpscope-dialog-buttons") != nullptr) {
+    row = last;
+  } else {
+    row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
+    gtk_widget_set_halign(row, GTK_ALIGN_END);
+    g_object_set_data(G_OBJECT(row), "udpscope-dialog-buttons", GINT_TO_POINTER(1));
+    gtk_box_append(GTK_BOX(box), row);
+  }
+  gtk_box_append(GTK_BOX(row), button);
+}
+
+}  // namespace ui_impl
+}  // namespace udpscope