From ab53600bd7a4a57a5765c1b3dfafe85b1c042acf Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Wed, 8 Mar 2017 22:51:39 -0800 Subject: 3768 - trace browser: scrolling horizontally --- html/100trace_browser.cc.html | 536 +++++++++++++++++++++--------------------- 1 file changed, 273 insertions(+), 263 deletions(-) (limited to 'html') diff --git a/html/100trace_browser.cc.html b/html/100trace_browser.cc.html index 812ba72e..c76aa4ac 100644 --- a/html/100trace_browser.cc.html +++ b/html/100trace_browser.cc.html @@ -91,271 +91,281 @@ if ('onhashchange' in window) { 31 //: `k` or `up-arrow`: Move/scroll cursor up one line. 32 //: `J` or `ctrl-f` or `page-down`: Scroll cursor down one page. 33 //: `K` or `ctrl-b` or `page-up`: Scroll cursor up one page. - 34 //: - 35 //: `g` or `home`: Move cursor to start of trace. - 36 //: `G` or `end`: Move cursor to end of trace. - 37 //: - 38 //: `t`: Move cursor to top line on screen. - 39 //: `c`: Move cursor to center line on screen. - 40 //: `b`: Move cursor to bottom line on screen. - 41 //: `T`: Scroll line at cursor to top of screen. - 42 - 43 :(before "End Primitive Recipe Declarations") - 44 _BROWSE_TRACE, - 45 :(before "End Primitive Recipe Numbers") - 46 put(Recipe_ordinal, "$browse-trace", _BROWSE_TRACE); - 47 :(before "End Primitive Recipe Checks") - 48 case _BROWSE_TRACE: { - 49 break; - 50 } - 51 :(before "End Primitive Recipe Implementations") - 52 case _BROWSE_TRACE: { - 53 start_trace_browser(); - 54 break; - 55 } - 56 - 57 //: browse a trace loaded from a file - 58 :(after "Commandline Parsing") - 59 if (argc == 3 && is_equal(argv[1], "browse-trace")) { - 60 load_trace(argv[2]); - 61 start_trace_browser(); - 62 return 0; - 63 } - 64 - 65 :(before "End Globals") - 66 set<int> Visible; - 67 int Top_of_screen = 0; - 68 int Last_printed_row = 0; - 69 map<int, int> Trace_index; // screen row -> trace index - 70 - 71 :(code) - 72 void start_trace_browser() { - 73 if (!Trace_stream) return; - 74 cerr << "computing min depth to display\n"; - 75 int min_depth = 9999; - 76 for (int i = 0; i < SIZE(Trace_stream->past_lines); ++i) { - 77 ¦ trace_line& curr_line = Trace_stream->past_lines.at(i); - 78 ¦ if (curr_line.depth < min_depth) min_depth = curr_line.depth; - 79 } - 80 cerr << "min depth is " << min_depth << '\n'; - 81 cerr << "computing lines to display\n"; - 82 for (int i = 0; i < SIZE(Trace_stream->past_lines); ++i) { - 83 ¦ if (Trace_stream->past_lines.at(i).depth == min_depth) - 84 ¦ ¦ Visible.insert(i); - 85 } - 86 tb_init(); - 87 Display_row = Display_column = 0; - 88 tb_event event; - 89 Top_of_screen = 0; - 90 refresh_screen_rows(); - 91 while (true) { - 92 ¦ render(); - 93 ¦ do { - 94 ¦ ¦ tb_poll_event(&event); - 95 ¦ } while (event.type != TB_EVENT_KEY); - 96 ¦ int key = event.key ? event.key : event.ch; - 97 ¦ if (key == 'q' || key == 'Q' || key == TB_KEY_CTRL_C) break; - 98 ¦ if (key == 'j' || key == TB_KEY_ARROW_DOWN) { - 99 ¦ ¦ // move cursor one line down -100 ¦ ¦ if (Display_row < Last_printed_row) ++Display_row; -101 ¦ } -102 ¦ if (key == 'k' || key == TB_KEY_ARROW_UP) { -103 ¦ ¦ // move cursor one line up -104 ¦ ¦ if (Display_row > 0) --Display_row; -105 ¦ } -106 ¦ if (key == 't') { -107 ¦ ¦ // move cursor to top of screen -108 ¦ ¦ Display_row = 0; -109 ¦ } -110 ¦ if (key == 'c') { -111 ¦ ¦ // move cursor to center of screen -112 ¦ ¦ Display_row = tb_height()/2; -113 ¦ } -114 ¦ if (key == 'b') { -115 ¦ ¦ // move cursor to bottom of screen -116 ¦ ¦ Display_row = tb_height()-1; -117 ¦ } -118 ¦ if (key == 'T') { -119 ¦ ¦ Top_of_screen = get(Trace_index, Display_row); -120 ¦ ¦ Display_row = 0; -121 ¦ ¦ refresh_screen_rows(); -122 ¦ } -123 ¦ if (key == 'J' || key == TB_KEY_PGDN || key == TB_KEY_CTRL_F) { -124 ¦ ¦ // page-down -125 ¦ ¦ if (Trace_index.find(tb_height()-1) != Trace_index.end()) { -126 ¦ ¦ ¦ Top_of_screen = get(Trace_index, tb_height()-1) + 1; -127 ¦ ¦ ¦ refresh_screen_rows(); -128 ¦ ¦ } + 34 //: `H`: Scroll cursor left one screen-width. + 35 //: `L`: Scroll cursor right one screen-width. + 36 //: + 37 //: `g` or `home`: Move cursor to start of trace. + 38 //: `G` or `end`: Move cursor to end of trace. + 39 //: + 40 //: `t`: Move cursor to top line on screen. + 41 //: `c`: Move cursor to center line on screen. + 42 //: `b`: Move cursor to bottom line on screen. + 43 //: `T`: Scroll line at cursor to top of screen. + 44 + 45 :(before "End Primitive Recipe Declarations") + 46 _BROWSE_TRACE, + 47 :(before "End Primitive Recipe Numbers") + 48 put(Recipe_ordinal, "$browse-trace", _BROWSE_TRACE); + 49 :(before "End Primitive Recipe Checks") + 50 case _BROWSE_TRACE: { + 51 break; + 52 } + 53 :(before "End Primitive Recipe Implementations") + 54 case _BROWSE_TRACE: { + 55 start_trace_browser(); + 56 break; + 57 } + 58 + 59 //: browse a trace loaded from a file + 60 :(after "Commandline Parsing") + 61 if (argc == 3 && is_equal(argv[1], "browse-trace")) { + 62 load_trace(argv[2]); + 63 start_trace_browser(); + 64 return 0; + 65 } + 66 + 67 :(before "End Globals") + 68 set<int> Visible; + 69 int Top_of_screen = 0; + 70 int Left_of_screen = 0; + 71 int Last_printed_row = 0; + 72 map<int, int> Trace_index; // screen row -> trace index + 73 + 74 :(code) + 75 void start_trace_browser() { + 76 if (!Trace_stream) return; + 77 cerr << "computing min depth to display\n"; + 78 int min_depth = 9999; + 79 for (int i = 0; i < SIZE(Trace_stream->past_lines); ++i) { + 80 ¦ trace_line& curr_line = Trace_stream->past_lines.at(i); + 81 ¦ if (curr_line.depth < min_depth) min_depth = curr_line.depth; + 82 } + 83 cerr << "min depth is " << min_depth << '\n'; + 84 cerr << "computing lines to display\n"; + 85 for (int i = 0; i < SIZE(Trace_stream->past_lines); ++i) { + 86 ¦ if (Trace_stream->past_lines.at(i).depth == min_depth) + 87 ¦ ¦ Visible.insert(i); + 88 } + 89 tb_init(); + 90 Display_row = Display_column = 0; + 91 tb_event event; + 92 Top_of_screen = 0; + 93 refresh_screen_rows(); + 94 while (true) { + 95 ¦ render(); + 96 ¦ do { + 97 ¦ ¦ tb_poll_event(&event); + 98 ¦ } while (event.type != TB_EVENT_KEY); + 99 ¦ int key = event.key ? event.key : event.ch; +100 ¦ if (key == 'q' || key == 'Q' || key == TB_KEY_CTRL_C) break; +101 ¦ if (key == 'j' || key == TB_KEY_ARROW_DOWN) { +102 ¦ ¦ // move cursor one line down +103 ¦ ¦ if (Display_row < Last_printed_row) ++Display_row; +104 ¦ } +105 ¦ if (key == 'k' || key == TB_KEY_ARROW_UP) { +106 ¦ ¦ // move cursor one line up +107 ¦ ¦ if (Display_row > 0) --Display_row; +108 ¦ } +109 ¦ if (key == 't') { +110 ¦ ¦ // move cursor to top of screen +111 ¦ ¦ Display_row = 0; +112 ¦ } +113 ¦ if (key == 'c') { +114 ¦ ¦ // move cursor to center of screen +115 ¦ ¦ Display_row = tb_height()/2; +116 ¦ } +117 ¦ if (key == 'b') { +118 ¦ ¦ // move cursor to bottom of screen +119 ¦ ¦ Display_row = tb_height()-1; +120 ¦ } +121 ¦ if (key == 'T') { +122 ¦ ¦ Top_of_screen = get(Trace_index, Display_row); +123 ¦ ¦ Display_row = 0; +124 ¦ ¦ refresh_screen_rows(); +125 ¦ } +126 ¦ if (key == 'H') { +127 ¦ ¦ Left_of_screen -= (tb_width() - 5); +128 ¦ ¦ if (Left_of_screen < 0) Left_of_screen = 0; 129 ¦ } -130 ¦ if (key == 'K' || key == TB_KEY_PGUP || key == TB_KEY_CTRL_B) { -131 ¦ ¦ // page-up is more convoluted -132 ¦ ¦ for (int screen_row = tb_height(); screen_row > 0 && Top_of_screen > 0; --screen_row) { -133 ¦ ¦ ¦ --Top_of_screen; -134 ¦ ¦ ¦ if (Top_of_screen <= 0) break; -135 ¦ ¦ ¦ while (Top_of_screen > 0 && !contains_key(Visible, Top_of_screen)) -136 ¦ ¦ ¦ ¦ --Top_of_screen; -137 ¦ ¦ } -138 ¦ ¦ if (Top_of_screen >= 0) -139 ¦ ¦ ¦ refresh_screen_rows(); -140 ¦ } -141 ¦ if (key == 'g' || key == TB_KEY_HOME) { -142 ¦ ¦ ¦ Top_of_screen = 0; -143 ¦ ¦ ¦ Last_printed_row = 0; -144 ¦ ¦ ¦ Display_row = 0; -145 ¦ ¦ ¦ refresh_screen_rows(); -146 ¦ } -147 ¦ if (key == 'G' || key == TB_KEY_END) { -148 ¦ ¦ // go to bottom of screen; largely like page-up, interestingly -149 ¦ ¦ Top_of_screen = SIZE(Trace_stream->past_lines)-1; -150 ¦ ¦ for (int screen_row = tb_height(); screen_row > 0 && Top_of_screen > 0; --screen_row) { -151 ¦ ¦ ¦ --Top_of_screen; -152 ¦ ¦ ¦ if (Top_of_screen <= 0) break; -153 ¦ ¦ ¦ while (Top_of_screen > 0 && !contains_key(Visible, Top_of_screen)) -154 ¦ ¦ ¦ ¦ --Top_of_screen; -155 ¦ ¦ } -156 ¦ ¦ refresh_screen_rows(); -157 ¦ ¦ // move cursor to bottom -158 ¦ ¦ Display_row = Last_printed_row; -159 ¦ ¦ refresh_screen_rows(); -160 ¦ } -161 ¦ if (key == TB_KEY_CARRIAGE_RETURN) { -162 ¦ ¦ // expand lines under current by one level -163 ¦ ¦ assert(contains_key(Trace_index, Display_row)); -164 ¦ ¦ int start_index = get(Trace_index, Display_row); -165 ¦ ¦ int index = 0; -166 ¦ ¦ // simultaneously compute end_index and min_depth -167 ¦ ¦ int min_depth = 9999; -168 ¦ ¦ for (index = start_index+1; index < SIZE(Trace_stream->past_lines); ++index) { -169 ¦ ¦ ¦ if (contains_key(Visible, index)) break; -170 ¦ ¦ ¦ trace_line& curr_line = Trace_stream->past_lines.at(index); -171 ¦ ¦ ¦ assert(curr_line.depth > Trace_stream->past_lines.at(start_index).depth); -172 ¦ ¦ ¦ if (curr_line.depth < min_depth) min_depth = curr_line.depth; -173 ¦ ¦ } -174 ¦ ¦ int end_index = index; -175 ¦ ¦ // mark as visible all intervening indices at min_depth -176 ¦ ¦ for (index = start_index; index < end_index; ++index) { -177 ¦ ¦ ¦ trace_line& curr_line = Trace_stream->past_lines.at(index); -178 ¦ ¦ ¦ if (curr_line.depth == min_depth) { -179 ¦ ¦ ¦ ¦ Visible.insert(index); -180 ¦ ¦ ¦ } -181 ¦ ¦ } -182 ¦ ¦ refresh_screen_rows(); -183 ¦ } -184 ¦ if (key == TB_KEY_BACKSPACE || key == TB_KEY_BACKSPACE2) { -185 ¦ ¦ // collapse all lines under current -186 ¦ ¦ assert(contains_key(Trace_index, Display_row)); -187 ¦ ¦ int start_index = get(Trace_index, Display_row); -188 ¦ ¦ int index = 0; -189 ¦ ¦ // end_index is the next line at a depth same as or lower than start_index -190 ¦ ¦ int initial_depth = Trace_stream->past_lines.at(start_index).depth; -191 ¦ ¦ for (index = start_index+1; index < SIZE(Trace_stream->past_lines); ++index) { -192 ¦ ¦ ¦ if (!contains_key(Visible, index)) continue; -193 ¦ ¦ ¦ trace_line& curr_line = Trace_stream->past_lines.at(index); -194 ¦ ¦ ¦ if (curr_line.depth <= initial_depth) break; -195 ¦ ¦ } -196 ¦ ¦ int end_index = index; -197 ¦ ¦ // mark as visible all intervening indices at min_depth -198 ¦ ¦ for (index = start_index+1; index < end_index; ++index) { -199 ¦ ¦ ¦ Visible.erase(index); -200 ¦ ¦ } -201 ¦ ¦ refresh_screen_rows(); -202 ¦ } -203 } -204 tb_shutdown(); -205 } -206 -207 // update Trace_indices for each screen_row on the basis of Top_of_screen and Visible -208 void refresh_screen_rows() { -209 int screen_row = 0, index = 0; -210 Trace_index.clear(); -211 for (screen_row = 0, index = Top_of_screen; screen_row < tb_height() && index < SIZE(Trace_stream->past_lines); ++screen_row, ++index) { -212 ¦ // skip lines without depth for now -213 ¦ while (!contains_key(Visible, index)) { -214 ¦ ¦ ++index; -215 ¦ ¦ if (index >= SIZE(Trace_stream->past_lines)) goto done; -216 ¦ } -217 ¦ assert(index < SIZE(Trace_stream->past_lines)); -218 ¦ put(Trace_index, screen_row, index); -219 } -220 done:; -221 } -222 -223 void render() { -224 int screen_row = 0; -225 for (screen_row = 0; screen_row < tb_height(); ++screen_row) { -226 ¦ if (!contains_key(Trace_index, screen_row)) break; -227 ¦ trace_line& curr_line = Trace_stream->past_lines.at(get(Trace_index, screen_row)); -228 ¦ ostringstream out; -229 ¦ out << std::setw(4) << curr_line.depth << ' ' << curr_line.label << ": " << curr_line.contents; -230 ¦ if (screen_row < tb_height()-1) { -231 ¦ ¦ int delta = lines_hidden(screen_row); -232 ¦ ¦ // home-brew escape sequence for red -233 ¦ ¦ if (delta > 999) out << static_cast<char>(1); -234 ¦ ¦ out << " (" << delta << ")"; -235 ¦ ¦ if (delta > 999) out << static_cast<char>(2); -236 ¦ } -237 ¦ render_line(screen_row, out.str(), screen_row == Display_row); -238 } -239 // clear rest of screen -240 Last_printed_row = screen_row-1; -241 for (; screen_row < tb_height(); ++screen_row) { -242 ¦ render_line(screen_row, "~", /*highlight?*/false); -243 } -244 // move cursor back to display row at the end -245 tb_set_cursor(0, Display_row); -246 tb_present(); -247 } -248 -249 int lines_hidden(int screen_row) { -250 assert(contains_key(Trace_index, screen_row)); -251 if (!contains_key(Trace_index, screen_row+1)) -252 ¦ return SIZE(Trace_stream->past_lines) - get(Trace_index, screen_row); -253 else -254 ¦ return get(Trace_index, screen_row+1) - get(Trace_index, screen_row); -255 } -256 -257 void render_line(int screen_row, const string& s, bool highlight) { -258 int col = 0; -259 int color = TB_WHITE; -260 for (col = 0; col < tb_width() && col < SIZE(s); ++col) { -261 ¦ char c = s.at(col); // todo: unicode -262 ¦ if (c == '\n') c = ';'; // replace newlines with semi-colons -263 ¦ // escapes. hack: can't start a line with them. -264 ¦ if (c == '\1') { color = /*red*/1; c = ' '; } -265 ¦ if (c == '\2') { color = TB_WHITE; c = ' '; } -266 ¦ tb_change_cell(col, screen_row, c, color, highlight ? /*subtle grey*/240 : TB_BLACK); -267 } -268 for (; col < tb_width(); ++col) -269 ¦ tb_change_cell(col, screen_row, ' ', TB_WHITE, highlight ? /*subtle grey*/240 : TB_BLACK); -270 } -271 -272 void load_trace(const char* filename) { -273 ifstream tin(filename); -274 if (!tin) { -275 ¦ cerr << "no such file: " << filename << '\n'; -276 ¦ exit(1); +130 ¦ if (key == 'L') { +131 ¦ ¦ Left_of_screen += (tb_width() - 5); +132 ¦ } +133 ¦ if (key == 'J' || key == TB_KEY_PGDN || key == TB_KEY_CTRL_F) { +134 ¦ ¦ // page-down +135 ¦ ¦ if (Trace_index.find(tb_height()-1) != Trace_index.end()) { +136 ¦ ¦ ¦ Top_of_screen = get(Trace_index, tb_height()-1) + 1; +137 ¦ ¦ ¦ refresh_screen_rows(); +138 ¦ ¦ } +139 ¦ } +140 ¦ if (key == 'K' || key == TB_KEY_PGUP || key == TB_KEY_CTRL_B) { +141 ¦ ¦ // page-up is more convoluted +142 ¦ ¦ for (int screen_row = tb_height(); screen_row > 0 && Top_of_screen > 0; --screen_row) { +143 ¦ ¦ ¦ --Top_of_screen; +144 ¦ ¦ ¦ if (Top_of_screen <= 0) break; +145 ¦ ¦ ¦ while (Top_of_screen > 0 && !contains_key(Visible, Top_of_screen)) +146 ¦ ¦ ¦ ¦ --Top_of_screen; +147 ¦ ¦ } +148 ¦ ¦ if (Top_of_screen >= 0) +149 ¦ ¦ ¦ refresh_screen_rows(); +150 ¦ } +151 ¦ if (key == 'g' || key == TB_KEY_HOME) { +152 ¦ ¦ ¦ Top_of_screen = 0; +153 ¦ ¦ ¦ Last_printed_row = 0; +154 ¦ ¦ ¦ Display_row = 0; +155 ¦ ¦ ¦ refresh_screen_rows(); +156 ¦ } +157 ¦ if (key == 'G' || key == TB_KEY_END) { +158 ¦ ¦ // go to bottom of screen; largely like page-up, interestingly +159 ¦ ¦ Top_of_screen = SIZE(Trace_stream->past_lines)-1; +160 ¦ ¦ for (int screen_row = tb_height(); screen_row > 0 && Top_of_screen > 0; --screen_row) { +161 ¦ ¦ ¦ --Top_of_screen; +162 ¦ ¦ ¦ if (Top_of_screen <= 0) break; +163 ¦ ¦ ¦ while (Top_of_screen > 0 && !contains_key(Visible, Top_of_screen)) +164 ¦ ¦ ¦ ¦ --Top_of_screen; +165 ¦ ¦ } +166 ¦ ¦ refresh_screen_rows(); +167 ¦ ¦ // move cursor to bottom +168 ¦ ¦ Display_row = Last_printed_row; +169 ¦ ¦ refresh_screen_rows(); +170 ¦ } +171 ¦ if (key == TB_KEY_CARRIAGE_RETURN) { +172 ¦ ¦ // expand lines under current by one level +173 ¦ ¦ assert(contains_key(Trace_index, Display_row)); +174 ¦ ¦ int start_index = get(Trace_index, Display_row); +175 ¦ ¦ int index = 0; +176 ¦ ¦ // simultaneously compute end_index and min_depth +177 ¦ ¦ int min_depth = 9999; +178 ¦ ¦ for (index = start_index+1; index < SIZE(Trace_stream->past_lines); ++index) { +179 ¦ ¦ ¦ if (contains_key(Visible, index)) break; +180 ¦ ¦ ¦ trace_line& curr_line = Trace_stream->past_lines.at(index); +181 ¦ ¦ ¦ assert(curr_line.depth > Trace_stream->past_lines.at(start_index).depth); +182 ¦ ¦ ¦ if (curr_line.depth < min_depth) min_depth = curr_line.depth; +183 ¦ ¦ } +184 ¦ ¦ int end_index = index; +185 ¦ ¦ // mark as visible all intervening indices at min_depth +186 ¦ ¦ for (index = start_index; index < end_index; ++index) { +187 ¦ ¦ ¦ trace_line& curr_line = Trace_stream->past_lines.at(index); +188 ¦ ¦ ¦ if (curr_line.depth == min_depth) { +189 ¦ ¦ ¦ ¦ Visible.insert(index); +190 ¦ ¦ ¦ } +191 ¦ ¦ } +192 ¦ ¦ refresh_screen_rows(); +193 ¦ } +194 ¦ if (key == TB_KEY_BACKSPACE || key == TB_KEY_BACKSPACE2) { +195 ¦ ¦ // collapse all lines under current +196 ¦ ¦ assert(contains_key(Trace_index, Display_row)); +197 ¦ ¦ int start_index = get(Trace_index, Display_row); +198 ¦ ¦ int index = 0; +199 ¦ ¦ // end_index is the next line at a depth same as or lower than start_index +200 ¦ ¦ int initial_depth = Trace_stream->past_lines.at(start_index).depth; +201 ¦ ¦ for (index = start_index+1; index < SIZE(Trace_stream->past_lines); ++index) { +202 ¦ ¦ ¦ if (!contains_key(Visible, index)) continue; +203 ¦ ¦ ¦ trace_line& curr_line = Trace_stream->past_lines.at(index); +204 ¦ ¦ ¦ if (curr_line.depth <= initial_depth) break; +205 ¦ ¦ } +206 ¦ ¦ int end_index = index; +207 ¦ ¦ // mark as visible all intervening indices at min_depth +208 ¦ ¦ for (index = start_index+1; index < end_index; ++index) { +209 ¦ ¦ ¦ Visible.erase(index); +210 ¦ ¦ } +211 ¦ ¦ refresh_screen_rows(); +212 ¦ } +213 } +214 tb_shutdown(); +215 } +216 +217 // update Trace_indices for each screen_row on the basis of Top_of_screen and Visible +218 void refresh_screen_rows() { +219 int screen_row = 0, index = 0; +220 Trace_index.clear(); +221 for (screen_row = 0, index = Top_of_screen; screen_row < tb_height() && index < SIZE(Trace_stream->past_lines); ++screen_row, ++index) { +222 ¦ // skip lines without depth for now +223 ¦ while (!contains_key(Visible, index)) { +224 ¦ ¦ ++index; +225 ¦ ¦ if (index >= SIZE(Trace_stream->past_lines)) goto done; +226 ¦ } +227 ¦ assert(index < SIZE(Trace_stream->past_lines)); +228 ¦ put(Trace_index, screen_row, index); +229 } +230 done:; +231 } +232 +233 void render() { +234 int screen_row = 0; +235 for (screen_row = 0; screen_row < tb_height(); ++screen_row) { +236 ¦ if (!contains_key(Trace_index, screen_row)) break; +237 ¦ trace_line& curr_line = Trace_stream->past_lines.at(get(Trace_index, screen_row)); +238 ¦ ostringstream out; +239 ¦ out << std::setw(4) << curr_line.depth << ' ' << curr_line.label << ": " << curr_line.contents; +240 ¦ if (screen_row < tb_height()-1) { +241 ¦ ¦ int delta = lines_hidden(screen_row); +242 ¦ ¦ // home-brew escape sequence for red +243 ¦ ¦ if (delta > 999) out << static_cast<char>(1); +244 ¦ ¦ out << " (" << delta << ")"; +245 ¦ ¦ if (delta > 999) out << static_cast<char>(2); +246 ¦ } +247 ¦ render_line(screen_row, out.str(), screen_row == Display_row); +248 } +249 // clear rest of screen +250 Last_printed_row = screen_row-1; +251 for (; screen_row < tb_height(); ++screen_row) { +252 ¦ render_line(screen_row, "~", /*highlight?*/false); +253 } +254 // move cursor back to display row at the end +255 tb_set_cursor(0, Display_row); +256 tb_present(); +257 } +258 +259 int lines_hidden(int screen_row) { +260 assert(contains_key(Trace_index, screen_row)); +261 if (!contains_key(Trace_index, screen_row+1)) +262 ¦ return SIZE(Trace_stream->past_lines) - get(Trace_index, screen_row); +263 else +264 ¦ return get(Trace_index, screen_row+1) - get(Trace_index, screen_row); +265 } +266 +267 void render_line(int screen_row, const string& s, bool highlight) { +268 int col = 0; +269 int color = TB_WHITE; +270 for (col = 0; col < tb_width() && col+Left_of_screen < SIZE(s); ++col) { +271 ¦ char c = s.at(col+Left_of_screen); // todo: unicode +272 ¦ if (c == '\n') c = ';'; // replace newlines with semi-colons +273 ¦ // escapes. hack: can't start a line with them. +274 ¦ if (c == '\1') { color = /*red*/1; c = ' '; } +275 ¦ if (c == '\2') { color = TB_WHITE; c = ' '; } +276 ¦ tb_change_cell(col, screen_row, c, color, highlight ? /*subtle grey*/240 : TB_BLACK); 277 } -278 Trace_stream = new trace_stream; -279 while (has_data(tin)) { -280 ¦ tin >> std::noskipws; -281 ¦ ¦ skip_whitespace_but_not_newline(tin); -282 ¦ ¦ if (!isdigit(tin.peek())) { -283 ¦ ¦ ¦ string dummy; -284 ¦ ¦ ¦ getline(tin, dummy); -285 ¦ ¦ ¦ continue; -286 ¦ ¦ } -287 ¦ tin >> std::skipws; -288 ¦ int depth; -289 ¦ tin >> depth; -290 ¦ string label; -291 ¦ tin >> label; -292 ¦ if (*--label.end() == ':') label.erase(--label.end()); -293 ¦ string line; -294 ¦ getline(tin, line); -295 ¦ Trace_stream->past_lines.push_back(trace_line(depth, label, line)); -296 } -297 cerr << "lines read: " << Trace_stream->past_lines.size() << '\n'; -298 } +278 for (; col < tb_width(); ++col) +279 ¦ tb_change_cell(col, screen_row, ' ', TB_WHITE, highlight ? /*subtle grey*/240 : TB_BLACK); +280 } +281 +282 void load_trace(const char* filename) { +283 ifstream tin(filename); +284 if (!tin) { +285 ¦ cerr << "no such file: " << filename << '\n'; +286 ¦ exit(1); +287 } +288 Trace_stream = new trace_stream; +289 while (has_data(tin)) { +290 ¦ tin >> std::noskipws; +291 ¦ ¦ skip_whitespace_but_not_newline(tin); +292 ¦ ¦ if (!isdigit(tin.peek())) { +293 ¦ ¦ ¦ string dummy; +294 ¦ ¦ ¦ getline(tin, dummy); +295 ¦ ¦ ¦ continue; +296 ¦ ¦ } +297 ¦ tin >> std::skipws; +298 ¦ int depth; +299 ¦ tin >> depth; +300 ¦ string label; +301 ¦ tin >> label; +302 ¦ if (*--label.end() == ':') label.erase(--label.end()); +303 ¦ string line; +304 ¦ getline(tin, line); +305 ¦ Trace_stream->past_lines.push_back(trace_line(depth, label, line)); +306 } +307 cerr << "lines read: " << Trace_stream->past_lines.size() << '\n'; +308 } -- cgit 1.4.1-2-gfad0