query result list: paginate instead of infinite scrolling

this simplifies the rendering ode considerably, and also leads to better
performance, so it's a win-win.

Author: algorithmiker

gui/src/main.rs

@@ -281,8 +281,6 @@ fn span(
         info!("Right-clicked {id}");
     }
     header_res.header_response.context_menu(|ui| {
-        if ui.button("Pop out").clicked() {};
-
         #[allow(irrefutable_let_patterns)]
         if let SpanContext::QueryResults { locating_state, trace_provider } = ctx {
             let enabled = locating_state.borrow().can_start_new();

gui/src/search/mod.rs

@@ -11,15 +11,15 @@ use std::{
 };
 
 use crate::{
-    LogState, TraceProvider, enbitvec::EnBitVec, notifications::draw_x, rect,
-    search::query_window::QueryLayoutCache, spawn_task,
+    LogState, TraceProvider, notifications::draw_x, rect, search::query_window::PaginatedResults,
+    spawn_task,
 };
 use crossbeam::channel::Receiver;
 use egui::{
     Color32, CornerRadius, Margin, Pos2, Rect, Response, RichText, Sense, Separator, Shape, Stroke,
     TextEdit, Ui, epaint::RectShape, pos2, vec2,
 };
-use entrace_query::lua_api::setup_lua_on_arc_rwlock;
+use entrace_query::{QueryError, lua_api::setup_lua_on_arc_rwlock};
 use mlua::{FromLua, Lua, Value};
 use tracing::{error, info};
 #[derive(Debug, Clone)]
@@ -30,8 +30,7 @@ pub struct PartialQueryResult {
 #[derive(Debug)]
 pub struct QueryResult {
     pub ids: Vec<u32>,
-    pub layout_cache: QueryLayoutCache,
-    cull_open_state: EnBitVec,
+    pub pages: PaginatedResults,
 }
 #[derive(Debug)]
 pub enum Query {
@@ -200,12 +199,7 @@ impl SearchState {
                 }
             }
             let ids_len = total_ids.len();
-            let cull_open_state = EnBitVec::repeat(false, ids_len);
-            let qr = QueryResult {
-                ids: total_ids,
-                cull_open_state,
-                layout_cache: QueryLayoutCache::new(),
-            };
+            let qr = QueryResult { ids: total_ids, pages: PaginatedResults::new(ids_len) };
             tx.send(Ok(qr)).ok();
         });
     }

gui/src/search/query_window.rs

@@ -1,53 +1,15 @@
-use egui::{Context, ScrollArea, Ui, vec2};
+use std::{cmp::min, fmt::Write, ops::Range};
+
+use egui::{Context, Layout, ScrollArea, Ui, Vec2, Widget};
 use entrace_core::display_error_context;
 use tracing::{error, info};
 
 use crate::{
-    App, LogState, LogStatus, SpanContext, row_height,
+    App, LogState, LogStatus, SpanContext,
     search::{Query, QueryError, QueryResult, QueryTiming, search_settings_dialog},
     span,
 };
 
-#[derive(Debug)]
-pub enum LayoutCommand {
-    Space(f32),
-    Span(u32),
-}
-#[derive(Debug)]
-pub struct QueryLayoutCache {
-    /// this is a bool instead of an option, so we can re-use the same [commands](QueryLayoutCache::commands) allocation in multiple successive
-    /// frames, since it is going to be similar in length
-    pub is_valid: bool,
-    pub commands: Vec<LayoutCommand>,
-    pub last_scroll_offset: Option<f32>,
-    pub last_inner_height: Option<f32>,
-}
-
-impl Default for QueryLayoutCache {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl QueryLayoutCache {
-    pub fn new() -> Self {
-        Self {
-            is_valid: false,
-            commands: Vec::with_capacity(32),
-            last_scroll_offset: None,
-            last_inner_height: None,
-        }
-    }
-    /// Convenience method for [QueryLayoutCache.commands::push]
-    pub fn push(&mut self, command: LayoutCommand) {
-        self.commands.push(command);
-    }
-    pub fn invalidate(&mut self) {
-        self.is_valid = false;
-        self.commands.clear();
-    }
-}
-
 pub fn query_windows(ui: &mut Ui, ctx: &Context, app: &mut App) {
     search_settings_dialog(ui, &mut app.search_state);
     for i in 0..app.search_state.queries.len() {
@@ -118,159 +80,71 @@ pub fn query_windows(ui: &mut Ui, ctx: &Context, app: &mut App) {
         i += 1;
     }
 }
-
-pub fn query_result_list(ui: &mut Ui, result: &mut QueryResult, log: &mut LogState) {
-    ui.label(format!("Got {} spans.", result.ids.len()));
-    let scroller = ScrollArea::new([false, true])
-        .auto_shrink([false, false])
-        .stick_to_bottom(false)
-        .show(ui, |ui| match result.layout_cache.is_valid {
-            true => result_list_cached(ui, result, log),
-            false => result_list_no_cache(ui, result, log),
-        });
-
-    let cache = &mut result.layout_cache;
-    let height = scroller.inner_rect.height();
-    let new_offset = scroller.state.offset.y;
-    if matches!(cache.last_inner_height, Some(last) if last != height)
-        || matches!(cache.last_scroll_offset, Some(last) if last != new_offset)
-    {
-        cache.invalidate();
-    }
-
-    cache.last_inner_height = Some(height);
-    cache.last_scroll_offset = Some(new_offset);
+#[derive(Debug)]
+pub struct PaginatedResults {
+    cur_page: usize,
+    page_size: usize,
+    nr_entries: usize,
+    page_entry_text: String,
 }
-fn result_list_cached(ui: &mut Ui, result: &mut QueryResult, log: &mut LogState) {
-    let log_reader = log.trace_provider.read().unwrap();
-    let cache = &mut result.layout_cache;
-    let mut ctx = SpanContext::QueryResults {
-        locating_state: &log.locating_state,
-        trace_provider: log.trace_provider.clone(),
-    };
-    let mut invalidate_cache = false;
-    for command in &cache.commands {
-        match command {
-            LayoutCommand::Space(x) => {
-                ui.allocate_space(vec2(10.0, *x));
-            }
-            LayoutCommand::Span(span_id) => {
-                let resp = span(ui, &mut ctx, &log_reader, *span_id);
-                if let Some(resp) = resp.header_response
-                    && resp.clicked()
-                {
-                    invalidate_cache = true;
-                    result.cull_open_state.toggle(*span_id as usize);
-                }
-            }
+impl PaginatedResults {
+    pub fn new(nr_entries: usize) -> PaginatedResults {
+        PaginatedResults {
+            cur_page: 0,
+            page_size: 100,
+            page_entry_text: String::from("0"),
+            nr_entries,
         }
     }
-    if invalidate_cache {
-        cache.invalidate();
+    pub fn cur_range(&self) -> Range<usize> {
+        let start = self.cur_page * self.page_size;
+        start..min(start + self.page_size, self.nr_entries)
     }
-}
-fn result_list_no_cache(ui: &mut Ui, result: &mut QueryResult, log: &mut LogState) {
-    let log_reader = log.trace_provider.read().unwrap();
-    let row_height = row_height(ui);
-    let cache = &mut result.layout_cache;
-    cache.invalidate();
-    let mut invalidate_cache = false;
-    let mut _non_culled_cnt = 0;
-    //let skippable_space = ui.clip_rect().min.y - ui.cursor().min.y;
-    //let skippable_rows = (skippable_space / row_height).max(0.0) as usize;
-    //ui.allocate_space(vec2(ui.available_width(), row_height * skippable_rows as f32));
-    //println!("Skipped rows: {skippable_rows}");
-    enum Region {
-        BeforeVisible(f32),
-        Visible,
-        AfterVisible(f32),
+    pub fn set_page(&mut self, new: usize) {
+        self.cur_page = min(new, self.page_cnt().saturating_sub(1));
+        self.page_entry_text.clear();
+        write!(self.page_entry_text, "{}", self.cur_page).ok();
     }
-    let mut region = Region::BeforeVisible(0.0);
-    //let mut region = Region::Visible;
-    let mut idx = 0;
-    let mut ctx = SpanContext::QueryResults {
-        locating_state: &log.locating_state,
-        trace_provider: log.trace_provider.clone(),
-    };
-    while idx < result.ids.len() {
-        let span_id = result.ids[idx];
-
-        match region {
-            Region::BeforeVisible(space_before) => {
-                let span_end_lower_bound =
-                    ui.cursor().min.y + space_before + row_height + ui.spacing().item_spacing.y;
-                let still_before_visible = span_end_lower_bound < ui.clip_rect().min.y;
-                //info!(span_end_lower_bound, clip_min = ui.clip_rect().min.y, "BeforeVisible");
-                if !still_before_visible {
-                    //println!("{idx} is (partially) visible. culled height before: {space_before}");
-                    ui.allocate_space(vec2(10.0, space_before.max(0.0)));
-                    cache.push(LayoutCommand::Space(space_before.max(0.0)));
-                    region = Region::Visible;
-                    continue;
-                }
-
-                if !result.cull_open_state.get(span_id as usize).unwrap_or(true) {
-                    region = Region::BeforeVisible(space_before + row_height);
-                } else {
-                    // if this span is open, then its children should be visible eveen
-                    // if the header is not. so draw it.
-                    // To draw it in the correct space, we allocate the (closed) space
-                    // before, then go again from 0.
-                    ui.allocate_space(vec2(10.0, space_before.max(0.0)));
-                    cache.push(LayoutCommand::Space(space_before.max(0.0)));
-                    // println!(
-                    //     "{idx} is open-culled, so allocated the current carry of {space_before} \
-                    //      before"
-                    // );
-                    span(ui, &mut ctx, &log_reader, span_id);
-                    cache.push(LayoutCommand::Span(span_id));
-                    region = Region::BeforeVisible(0.0);
-                }
-            }
-            Region::Visible => {
-                //println!("Visible({idx})");
-                let resp = span(ui, &mut ctx, &log_reader, span_id);
-                cache.push(LayoutCommand::Span(span_id));
-                _non_culled_cnt += 1;
-                if let Some(resp) = resp.header_response {
-                    if ui.clip_rect().max.y <= resp.rect.min.y {
-                        region = Region::AfterVisible(0.0);
-                        idx += 1;
-                        continue;
-                    }
-                    if resp.clicked() {
-                        invalidate_cache = true;
-                        result.cull_open_state.toggle(idx);
-                    }
-                }
-                if idx == result.ids.len().saturating_sub(1) {
-                    ui.allocate_space(vec2(10.0, row_height * 3.0));
-                    cache.push(LayoutCommand::Space(row_height * 3.0));
-                }
-            }
-            Region::AfterVisible(after_space) => {
-                if !result.cull_open_state.get(idx).unwrap_or(true) {
-                    region = Region::AfterVisible(after_space + row_height);
-                } else {
-                    ui.allocate_space(vec2(10.0, after_space.max(0.0)));
-                    cache.push(LayoutCommand::Space(after_space.max(0.0)));
-
-                    //println!("{idx} is open-culled, so allocated the current carry of {after_space} before");
-                    span(ui, &mut ctx, &log_reader, span_id);
-                    cache.push(LayoutCommand::Span(span_id));
-                    region = Region::AfterVisible(0.0);
-                }
-            }
-        }
-        idx += 1;
-    }
-    if let Region::AfterVisible(after_space) = region {
-        ui.allocate_space(vec2(10.0, after_space));
-        cache.push(LayoutCommand::Space(after_space.max(0.0)));
+    pub fn page_cnt(&self) -> usize {
+        self.nr_entries.div_ceil(self.page_size)
     }
-    if invalidate_cache {
-        cache.invalidate();
-    }
-    cache.is_valid = true;
-    //println!("Not culled: {non_culled_cnt}");
+}
+pub fn result_list_pagination(ui: &mut Ui, result: &mut QueryResult) {
+    ui.allocate_ui_with_layout(Vec2::ZERO, Layout::left_to_right(egui::Align::Center), |ui| {
+        if ui.button("<").clicked() {
+            result.pages.set_page(result.pages.cur_page.saturating_sub(1));
+        }
+        ui.label("Page ");
+        let ed = egui::TextEdit::singleline(&mut result.pages.page_entry_text)
+            .desired_width(0.0)
+            .clip_text(false)
+            .ui(ui);
+        if ed.lost_focus()
+            && let Ok(x) = str::parse::<usize>(&result.pages.page_entry_text)
+        {
+            result.pages.set_page(x);
+        }
+        ui.label(format!("/ {}", result.pages.page_cnt()));
+        if ui.button(">").clicked() {
+            result.pages.set_page(result.pages.cur_page.saturating_add(1));
+        }
+    });
+}
+pub fn query_result_list(ui: &mut Ui, result: &mut QueryResult, log: &mut LogState) {
+    ui.label(format!("Got {} spans.", result.ids.len()));
+    result_list_pagination(ui, result);
+    ScrollArea::new([false, true]).auto_shrink([false, false]).stick_to_bottom(false).show(
+        ui,
+        |ui| {
+            let result_range = result.pages.cur_range();
+            let log_reader = log.trace_provider.read().unwrap();
+            let mut ctx = SpanContext::QueryResults {
+                locating_state: &log.locating_state,
+                trace_provider: log.trace_provider.clone(),
+            };
+            for id in result_range {
+                span(ui, &mut ctx, &log_reader, result.ids[id]);
+            }
+        },
+    );
 }