Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 #include "../util/string2.h"
0003 #include "../util/config.h"
0004 #include "libslang.h"
0005 #include "ui.h"
0006 #include "util.h"
0007 #include <linux/compiler.h>
0008 #include <linux/list.h>
0009 #include <linux/rbtree.h>
0010 #include <linux/string.h>
0011 #include <stdlib.h>
0012 #include <sys/ttydefaults.h>
0013 #include "browser.h"
0014 #include "helpline.h"
0015 #include "keysyms.h"
0016 #include "../util/color.h"
0017 #include <linux/ctype.h>
0018 #include <linux/zalloc.h>
0019 
0020 static int ui_browser__percent_color(struct ui_browser *browser,
0021                      double percent, bool current)
0022 {
0023     if (current && (!browser->use_navkeypressed || browser->navkeypressed))
0024         return HE_COLORSET_SELECTED;
0025     if (percent >= MIN_RED)
0026         return HE_COLORSET_TOP;
0027     if (percent >= MIN_GREEN)
0028         return HE_COLORSET_MEDIUM;
0029     return HE_COLORSET_NORMAL;
0030 }
0031 
0032 int ui_browser__set_color(struct ui_browser *browser, int color)
0033 {
0034     int ret = browser->current_color;
0035     browser->current_color = color;
0036     SLsmg_set_color(color);
0037     return ret;
0038 }
0039 
0040 void ui_browser__set_percent_color(struct ui_browser *browser,
0041                    double percent, bool current)
0042 {
0043      int color = ui_browser__percent_color(browser, percent, current);
0044      ui_browser__set_color(browser, color);
0045 }
0046 
0047 void ui_browser__gotorc_title(struct ui_browser *browser, int y, int x)
0048 {
0049     SLsmg_gotorc(browser->y + y, browser->x + x);
0050 }
0051 
0052 void ui_browser__gotorc(struct ui_browser *browser, int y, int x)
0053 {
0054     SLsmg_gotorc(browser->y + y + browser->extra_title_lines, browser->x + x);
0055 }
0056 
0057 void ui_browser__write_nstring(struct ui_browser *browser __maybe_unused, const char *msg,
0058                    unsigned int width)
0059 {
0060     slsmg_write_nstring(msg, width);
0061 }
0062 
0063 void ui_browser__vprintf(struct ui_browser *browser __maybe_unused, const char *fmt, va_list args)
0064 {
0065     slsmg_vprintf(fmt, args);
0066 }
0067 
0068 void ui_browser__printf(struct ui_browser *browser __maybe_unused, const char *fmt, ...)
0069 {
0070     va_list args;
0071 
0072     va_start(args, fmt);
0073     ui_browser__vprintf(browser, fmt, args);
0074     va_end(args);
0075 }
0076 
0077 static struct list_head *
0078 ui_browser__list_head_filter_entries(struct ui_browser *browser,
0079                      struct list_head *pos)
0080 {
0081     do {
0082         if (!browser->filter || !browser->filter(browser, pos))
0083             return pos;
0084         pos = pos->next;
0085     } while (pos != browser->entries);
0086 
0087     return NULL;
0088 }
0089 
0090 static struct list_head *
0091 ui_browser__list_head_filter_prev_entries(struct ui_browser *browser,
0092                       struct list_head *pos)
0093 {
0094     do {
0095         if (!browser->filter || !browser->filter(browser, pos))
0096             return pos;
0097         pos = pos->prev;
0098     } while (pos != browser->entries);
0099 
0100     return NULL;
0101 }
0102 
0103 void ui_browser__list_head_seek(struct ui_browser *browser, off_t offset, int whence)
0104 {
0105     struct list_head *head = browser->entries;
0106     struct list_head *pos;
0107 
0108     if (browser->nr_entries == 0)
0109         return;
0110 
0111     switch (whence) {
0112     case SEEK_SET:
0113         pos = ui_browser__list_head_filter_entries(browser, head->next);
0114         break;
0115     case SEEK_CUR:
0116         pos = browser->top;
0117         break;
0118     case SEEK_END:
0119         pos = ui_browser__list_head_filter_prev_entries(browser, head->prev);
0120         break;
0121     default:
0122         return;
0123     }
0124 
0125     assert(pos != NULL);
0126 
0127     if (offset > 0) {
0128         while (offset-- != 0)
0129             pos = ui_browser__list_head_filter_entries(browser, pos->next);
0130     } else {
0131         while (offset++ != 0)
0132             pos = ui_browser__list_head_filter_prev_entries(browser, pos->prev);
0133     }
0134 
0135     browser->top = pos;
0136 }
0137 
0138 void ui_browser__rb_tree_seek(struct ui_browser *browser, off_t offset, int whence)
0139 {
0140     struct rb_root *root = browser->entries;
0141     struct rb_node *nd;
0142 
0143     switch (whence) {
0144     case SEEK_SET:
0145         nd = rb_first(root);
0146         break;
0147     case SEEK_CUR:
0148         nd = browser->top;
0149         break;
0150     case SEEK_END:
0151         nd = rb_last(root);
0152         break;
0153     default:
0154         return;
0155     }
0156 
0157     if (offset > 0) {
0158         while (offset-- != 0)
0159             nd = rb_next(nd);
0160     } else {
0161         while (offset++ != 0)
0162             nd = rb_prev(nd);
0163     }
0164 
0165     browser->top = nd;
0166 }
0167 
0168 unsigned int ui_browser__rb_tree_refresh(struct ui_browser *browser)
0169 {
0170     struct rb_node *nd;
0171     int row = 0;
0172 
0173     if (browser->top == NULL)
0174                 browser->top = rb_first(browser->entries);
0175 
0176     nd = browser->top;
0177 
0178     while (nd != NULL) {
0179         ui_browser__gotorc(browser, row, 0);
0180         browser->write(browser, nd, row);
0181         if (++row == browser->rows)
0182             break;
0183         nd = rb_next(nd);
0184     }
0185 
0186     return row;
0187 }
0188 
0189 bool ui_browser__is_current_entry(struct ui_browser *browser, unsigned row)
0190 {
0191     return browser->top_idx + row == browser->index;
0192 }
0193 
0194 void ui_browser__refresh_dimensions(struct ui_browser *browser)
0195 {
0196     browser->width = SLtt_Screen_Cols - 1;
0197     browser->height = browser->rows = SLtt_Screen_Rows - 2;
0198     browser->rows -= browser->extra_title_lines;
0199     browser->y = 1;
0200     browser->x = 0;
0201 }
0202 
0203 void ui_browser__handle_resize(struct ui_browser *browser)
0204 {
0205     ui__refresh_dimensions(false);
0206     ui_browser__show(browser, browser->title, ui_helpline__current);
0207     ui_browser__refresh(browser);
0208 }
0209 
0210 int ui_browser__warning(struct ui_browser *browser, int timeout,
0211             const char *format, ...)
0212 {
0213     va_list args;
0214     char *text;
0215     int key = 0, err;
0216 
0217     va_start(args, format);
0218     err = vasprintf(&text, format, args);
0219     va_end(args);
0220 
0221     if (err < 0) {
0222         va_start(args, format);
0223         ui_helpline__vpush(format, args);
0224         va_end(args);
0225     } else {
0226         while ((key = ui__question_window("Warning!", text,
0227                            "Press any key...",
0228                            timeout)) == K_RESIZE)
0229             ui_browser__handle_resize(browser);
0230         free(text);
0231     }
0232 
0233     return key;
0234 }
0235 
0236 int ui_browser__help_window(struct ui_browser *browser, const char *text)
0237 {
0238     int key;
0239 
0240     while ((key = ui__help_window(text)) == K_RESIZE)
0241         ui_browser__handle_resize(browser);
0242 
0243     return key;
0244 }
0245 
0246 bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text)
0247 {
0248     int key;
0249 
0250     while ((key = ui__dialog_yesno(text)) == K_RESIZE)
0251         ui_browser__handle_resize(browser);
0252 
0253     return key == K_ENTER || toupper(key) == 'Y';
0254 }
0255 
0256 void ui_browser__reset_index(struct ui_browser *browser)
0257 {
0258     browser->index = browser->top_idx = 0;
0259     browser->seek(browser, 0, SEEK_SET);
0260 }
0261 
0262 void __ui_browser__show_title(struct ui_browser *browser, const char *title)
0263 {
0264     SLsmg_gotorc(0, 0);
0265     ui_browser__set_color(browser, HE_COLORSET_ROOT);
0266     ui_browser__write_nstring(browser, title, browser->width + 1);
0267 }
0268 
0269 void ui_browser__show_title(struct ui_browser *browser, const char *title)
0270 {
0271     pthread_mutex_lock(&ui__lock);
0272     __ui_browser__show_title(browser, title);
0273     pthread_mutex_unlock(&ui__lock);
0274 }
0275 
0276 int ui_browser__show(struct ui_browser *browser, const char *title,
0277              const char *helpline, ...)
0278 {
0279     int err;
0280     va_list ap;
0281 
0282     if (browser->refresh_dimensions == NULL)
0283         browser->refresh_dimensions = ui_browser__refresh_dimensions;
0284 
0285     browser->refresh_dimensions(browser);
0286 
0287     pthread_mutex_lock(&ui__lock);
0288     __ui_browser__show_title(browser, title);
0289 
0290     browser->title = title;
0291     zfree(&browser->helpline);
0292 
0293     va_start(ap, helpline);
0294     err = vasprintf(&browser->helpline, helpline, ap);
0295     va_end(ap);
0296     if (err > 0)
0297         ui_helpline__push(browser->helpline);
0298     pthread_mutex_unlock(&ui__lock);
0299     return err ? 0 : -1;
0300 }
0301 
0302 void ui_browser__hide(struct ui_browser *browser)
0303 {
0304     pthread_mutex_lock(&ui__lock);
0305     ui_helpline__pop();
0306     zfree(&browser->helpline);
0307     pthread_mutex_unlock(&ui__lock);
0308 }
0309 
0310 static void ui_browser__scrollbar_set(struct ui_browser *browser)
0311 {
0312     int height = browser->height, h = 0, pct = 0,
0313         col = browser->width,
0314         row = 0;
0315 
0316     if (browser->nr_entries > 1) {
0317         pct = ((browser->index * (browser->height - 1)) /
0318                (browser->nr_entries - 1));
0319     }
0320 
0321     SLsmg_set_char_set(1);
0322 
0323     while (h < height) {
0324             ui_browser__gotorc(browser, row++, col);
0325         SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_CKBRD_CHAR);
0326         ++h;
0327     }
0328 
0329     SLsmg_set_char_set(0);
0330 }
0331 
0332 static int __ui_browser__refresh(struct ui_browser *browser)
0333 {
0334     int row;
0335     int width = browser->width;
0336 
0337     row = browser->refresh(browser);
0338     ui_browser__set_color(browser, HE_COLORSET_NORMAL);
0339 
0340     if (!browser->use_navkeypressed || browser->navkeypressed)
0341         ui_browser__scrollbar_set(browser);
0342     else
0343         width += 1;
0344 
0345     SLsmg_fill_region(browser->y + row + browser->extra_title_lines, browser->x,
0346               browser->rows - row, width, ' ');
0347 
0348     if (browser->nr_entries == 0 && browser->no_samples_msg)
0349         __ui__info_window(NULL, browser->no_samples_msg, NULL);
0350     return 0;
0351 }
0352 
0353 int ui_browser__refresh(struct ui_browser *browser)
0354 {
0355     pthread_mutex_lock(&ui__lock);
0356     __ui_browser__refresh(browser);
0357     pthread_mutex_unlock(&ui__lock);
0358 
0359     return 0;
0360 }
0361 
0362 /*
0363  * Here we're updating nr_entries _after_ we started browsing, i.e.  we have to
0364  * forget about any reference to any entry in the underlying data structure,
0365  * that is why we do a SEEK_SET. Think about 'perf top' in the hists browser
0366  * after an output_resort and hist decay.
0367  */
0368 void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries)
0369 {
0370     off_t offset = nr_entries - browser->nr_entries;
0371 
0372     browser->nr_entries = nr_entries;
0373 
0374     if (offset < 0) {
0375         if (browser->top_idx < (u64)-offset)
0376             offset = -browser->top_idx;
0377 
0378         browser->index += offset;
0379         browser->top_idx += offset;
0380     }
0381 
0382     browser->top = NULL;
0383     browser->seek(browser, browser->top_idx, SEEK_SET);
0384 }
0385 
0386 int ui_browser__run(struct ui_browser *browser, int delay_secs)
0387 {
0388     int err, key;
0389 
0390     while (1) {
0391         off_t offset;
0392 
0393         pthread_mutex_lock(&ui__lock);
0394         err = __ui_browser__refresh(browser);
0395         SLsmg_refresh();
0396         pthread_mutex_unlock(&ui__lock);
0397         if (err < 0)
0398             break;
0399 
0400         key = ui__getch(delay_secs);
0401 
0402         if (key == K_RESIZE) {
0403             ui__refresh_dimensions(false);
0404             browser->refresh_dimensions(browser);
0405             __ui_browser__show_title(browser, browser->title);
0406             ui_helpline__puts(browser->helpline);
0407             continue;
0408         }
0409 
0410         if (browser->use_navkeypressed && !browser->navkeypressed) {
0411             if (key == K_DOWN || key == K_UP ||
0412                 (browser->columns && (key == K_LEFT || key == K_RIGHT)) ||
0413                 key == K_PGDN || key == K_PGUP ||
0414                 key == K_HOME || key == K_END ||
0415                 key == ' ') {
0416                 browser->navkeypressed = true;
0417                 continue;
0418             } else
0419                 return key;
0420         }
0421 
0422         switch (key) {
0423         case K_DOWN:
0424             if (browser->index == browser->nr_entries - 1)
0425                 break;
0426             ++browser->index;
0427             if (browser->index == browser->top_idx + browser->rows) {
0428                 ++browser->top_idx;
0429                 browser->seek(browser, +1, SEEK_CUR);
0430             }
0431             break;
0432         case K_UP:
0433             if (browser->index == 0)
0434                 break;
0435             --browser->index;
0436             if (browser->index < browser->top_idx) {
0437                 --browser->top_idx;
0438                 browser->seek(browser, -1, SEEK_CUR);
0439             }
0440             break;
0441         case K_RIGHT:
0442             if (!browser->columns)
0443                 goto out;
0444             if (browser->horiz_scroll < browser->columns - 1)
0445                 ++browser->horiz_scroll;
0446             break;
0447         case K_LEFT:
0448             if (!browser->columns)
0449                 goto out;
0450             if (browser->horiz_scroll != 0)
0451                 --browser->horiz_scroll;
0452             break;
0453         case K_PGDN:
0454         case ' ':
0455             if (browser->top_idx + browser->rows > browser->nr_entries - 1)
0456                 break;
0457 
0458             offset = browser->rows;
0459             if (browser->index + offset > browser->nr_entries - 1)
0460                 offset = browser->nr_entries - 1 - browser->index;
0461             browser->index += offset;
0462             browser->top_idx += offset;
0463             browser->seek(browser, +offset, SEEK_CUR);
0464             break;
0465         case K_PGUP:
0466             if (browser->top_idx == 0)
0467                 break;
0468 
0469             if (browser->top_idx < browser->rows)
0470                 offset = browser->top_idx;
0471             else
0472                 offset = browser->rows;
0473 
0474             browser->index -= offset;
0475             browser->top_idx -= offset;
0476             browser->seek(browser, -offset, SEEK_CUR);
0477             break;
0478         case K_HOME:
0479             ui_browser__reset_index(browser);
0480             break;
0481         case K_END:
0482             offset = browser->rows - 1;
0483             if (offset >= browser->nr_entries)
0484                 offset = browser->nr_entries - 1;
0485 
0486             browser->index = browser->nr_entries - 1;
0487             browser->top_idx = browser->index - offset;
0488             browser->seek(browser, -offset, SEEK_END);
0489             break;
0490         default:
0491         out:
0492             return key;
0493         }
0494     }
0495     return -1;
0496 }
0497 
0498 unsigned int ui_browser__list_head_refresh(struct ui_browser *browser)
0499 {
0500     struct list_head *pos;
0501     struct list_head *head = browser->entries;
0502     int row = 0;
0503 
0504     if (browser->top == NULL || browser->top == browser->entries)
0505                 browser->top = ui_browser__list_head_filter_entries(browser, head->next);
0506 
0507     pos = browser->top;
0508 
0509     list_for_each_from(pos, head) {
0510         if (!browser->filter || !browser->filter(browser, pos)) {
0511             ui_browser__gotorc(browser, row, 0);
0512             browser->write(browser, pos, row);
0513             if (++row == browser->rows)
0514                 break;
0515         }
0516     }
0517 
0518     return row;
0519 }
0520 
0521 static struct ui_browser_colorset {
0522     const char *name, *fg, *bg;
0523     int colorset;
0524 } ui_browser__colorsets[] = {
0525     {
0526         .colorset = HE_COLORSET_TOP,
0527         .name     = "top",
0528         .fg   = "red",
0529         .bg   = "default",
0530     },
0531     {
0532         .colorset = HE_COLORSET_MEDIUM,
0533         .name     = "medium",
0534         .fg   = "green",
0535         .bg   = "default",
0536     },
0537     {
0538         .colorset = HE_COLORSET_NORMAL,
0539         .name     = "normal",
0540         .fg   = "default",
0541         .bg   = "default",
0542     },
0543     {
0544         .colorset = HE_COLORSET_SELECTED,
0545         .name     = "selected",
0546         .fg   = "black",
0547         .bg   = "yellow",
0548     },
0549     {
0550         .colorset = HE_COLORSET_JUMP_ARROWS,
0551         .name     = "jump_arrows",
0552         .fg   = "blue",
0553         .bg   = "default",
0554     },
0555     {
0556         .colorset = HE_COLORSET_ADDR,
0557         .name     = "addr",
0558         .fg   = "magenta",
0559         .bg   = "default",
0560     },
0561     {
0562         .colorset = HE_COLORSET_ROOT,
0563         .name     = "root",
0564         .fg   = "white",
0565         .bg   = "blue",
0566     },
0567     {
0568         .name = NULL,
0569     }
0570 };
0571 
0572 
0573 static int ui_browser__color_config(const char *var, const char *value,
0574                     void *data __maybe_unused)
0575 {
0576     char *fg = NULL, *bg;
0577     int i;
0578 
0579     /* same dir for all commands */
0580     if (!strstarts(var, "colors.") != 0)
0581         return 0;
0582 
0583     for (i = 0; ui_browser__colorsets[i].name != NULL; ++i) {
0584         const char *name = var + 7;
0585 
0586         if (strcmp(ui_browser__colorsets[i].name, name) != 0)
0587             continue;
0588 
0589         fg = strdup(value);
0590         if (fg == NULL)
0591             break;
0592 
0593         bg = strchr(fg, ',');
0594         if (bg == NULL)
0595             break;
0596 
0597         *bg = '\0';
0598         bg = skip_spaces(bg + 1);
0599         ui_browser__colorsets[i].bg = bg;
0600         ui_browser__colorsets[i].fg = fg;
0601         return 0;
0602     }
0603 
0604     free(fg);
0605     return -1;
0606 }
0607 
0608 void ui_browser__argv_seek(struct ui_browser *browser, off_t offset, int whence)
0609 {
0610     switch (whence) {
0611     case SEEK_SET:
0612         browser->top = browser->entries;
0613         break;
0614     case SEEK_CUR:
0615         browser->top = (char **)browser->top + offset;
0616         break;
0617     case SEEK_END:
0618         browser->top = (char **)browser->entries + browser->nr_entries - 1 + offset;
0619         break;
0620     default:
0621         return;
0622     }
0623     assert((char **)browser->top < (char **)browser->entries + browser->nr_entries);
0624     assert((char **)browser->top >= (char **)browser->entries);
0625 }
0626 
0627 unsigned int ui_browser__argv_refresh(struct ui_browser *browser)
0628 {
0629     unsigned int row = 0, idx = browser->top_idx;
0630     char **pos;
0631 
0632     if (browser->top == NULL)
0633         browser->top = browser->entries;
0634 
0635     pos = (char **)browser->top;
0636     while (idx < browser->nr_entries &&
0637            row < (unsigned)SLtt_Screen_Rows - 1) {
0638         assert(pos < (char **)browser->entries + browser->nr_entries);
0639         if (!browser->filter || !browser->filter(browser, *pos)) {
0640             ui_browser__gotorc(browser, row, 0);
0641             browser->write(browser, pos, row);
0642             if (++row == browser->rows)
0643                 break;
0644         }
0645 
0646         ++idx;
0647         ++pos;
0648     }
0649 
0650     return row;
0651 }
0652 
0653 void __ui_browser__vline(struct ui_browser *browser, unsigned int column,
0654              u16 start, u16 end)
0655 {
0656     SLsmg_set_char_set(1);
0657     ui_browser__gotorc(browser, start, column);
0658     SLsmg_draw_vline(end - start + 1);
0659     SLsmg_set_char_set(0);
0660 }
0661 
0662 void ui_browser__write_graph(struct ui_browser *browser __maybe_unused,
0663                  int graph)
0664 {
0665     SLsmg_set_char_set(1);
0666     SLsmg_write_char(graph);
0667     SLsmg_set_char_set(0);
0668 }
0669 
0670 static void __ui_browser__line_arrow_up(struct ui_browser *browser,
0671                     unsigned int column,
0672                     u64 start, u64 end)
0673 {
0674     unsigned int row, end_row;
0675 
0676     SLsmg_set_char_set(1);
0677 
0678     if (start < browser->top_idx + browser->rows) {
0679         row = start - browser->top_idx;
0680         ui_browser__gotorc(browser, row, column);
0681         SLsmg_write_char(SLSMG_LLCORN_CHAR);
0682         ui_browser__gotorc(browser, row, column + 1);
0683         SLsmg_draw_hline(2);
0684 
0685         if (row-- == 0)
0686             goto out;
0687     } else
0688         row = browser->rows - 1;
0689 
0690     if (end > browser->top_idx)
0691         end_row = end - browser->top_idx;
0692     else
0693         end_row = 0;
0694 
0695     ui_browser__gotorc(browser, end_row, column);
0696     SLsmg_draw_vline(row - end_row + 1);
0697 
0698     ui_browser__gotorc(browser, end_row, column);
0699     if (end >= browser->top_idx) {
0700         SLsmg_write_char(SLSMG_ULCORN_CHAR);
0701         ui_browser__gotorc(browser, end_row, column + 1);
0702         SLsmg_write_char(SLSMG_HLINE_CHAR);
0703         ui_browser__gotorc(browser, end_row, column + 2);
0704         SLsmg_write_char(SLSMG_RARROW_CHAR);
0705     }
0706 out:
0707     SLsmg_set_char_set(0);
0708 }
0709 
0710 static void __ui_browser__line_arrow_down(struct ui_browser *browser,
0711                       unsigned int column,
0712                       u64 start, u64 end)
0713 {
0714     unsigned int row, end_row;
0715 
0716     SLsmg_set_char_set(1);
0717 
0718     if (start >= browser->top_idx) {
0719         row = start - browser->top_idx;
0720         ui_browser__gotorc(browser, row, column);
0721         SLsmg_write_char(SLSMG_ULCORN_CHAR);
0722         ui_browser__gotorc(browser, row, column + 1);
0723         SLsmg_draw_hline(2);
0724 
0725         if (++row == 0)
0726             goto out;
0727     } else
0728         row = 0;
0729 
0730     if (end >= browser->top_idx + browser->rows)
0731         end_row = browser->rows - 1;
0732     else
0733         end_row = end - browser->top_idx;
0734 
0735     ui_browser__gotorc(browser, row, column);
0736     SLsmg_draw_vline(end_row - row + 1);
0737 
0738     ui_browser__gotorc(browser, end_row, column);
0739     if (end < browser->top_idx + browser->rows) {
0740         SLsmg_write_char(SLSMG_LLCORN_CHAR);
0741         ui_browser__gotorc(browser, end_row, column + 1);
0742         SLsmg_write_char(SLSMG_HLINE_CHAR);
0743         ui_browser__gotorc(browser, end_row, column + 2);
0744         SLsmg_write_char(SLSMG_RARROW_CHAR);
0745     }
0746 out:
0747     SLsmg_set_char_set(0);
0748 }
0749 
0750 void __ui_browser__line_arrow(struct ui_browser *browser, unsigned int column,
0751                   u64 start, u64 end)
0752 {
0753     if (start > end)
0754         __ui_browser__line_arrow_up(browser, column, start, end);
0755     else
0756         __ui_browser__line_arrow_down(browser, column, start, end);
0757 }
0758 
0759 void ui_browser__mark_fused(struct ui_browser *browser, unsigned int column,
0760                 unsigned int row, int diff, bool arrow_down)
0761 {
0762     int end_row;
0763 
0764     if (diff <= 0)
0765         return;
0766 
0767     SLsmg_set_char_set(1);
0768 
0769     if (arrow_down) {
0770         if (row + diff <= browser->top_idx)
0771             return;
0772 
0773         end_row = row + diff - browser->top_idx;
0774         ui_browser__gotorc(browser, end_row, column - 1);
0775         SLsmg_write_char(SLSMG_LTEE_CHAR);
0776 
0777         while (--end_row >= 0 && end_row > (int)(row - browser->top_idx)) {
0778             ui_browser__gotorc(browser, end_row, column - 1);
0779             SLsmg_draw_vline(1);
0780         }
0781 
0782         end_row = (int)(row - browser->top_idx);
0783         if (end_row >= 0) {
0784             ui_browser__gotorc(browser, end_row, column - 1);
0785             SLsmg_write_char(SLSMG_ULCORN_CHAR);
0786             ui_browser__gotorc(browser, end_row, column);
0787             SLsmg_draw_hline(2);
0788         }
0789     } else {
0790         if (row < browser->top_idx)
0791             return;
0792 
0793         end_row = row - browser->top_idx;
0794         ui_browser__gotorc(browser, end_row, column - 1);
0795         SLsmg_write_char(SLSMG_LTEE_CHAR);
0796         ui_browser__gotorc(browser, end_row, column);
0797         SLsmg_draw_hline(2);
0798     }
0799 
0800     SLsmg_set_char_set(0);
0801 }
0802 
0803 void ui_browser__init(void)
0804 {
0805     int i = 0;
0806 
0807     perf_config(ui_browser__color_config, NULL);
0808 
0809     while (ui_browser__colorsets[i].name) {
0810         struct ui_browser_colorset *c = &ui_browser__colorsets[i++];
0811         sltt_set_color(c->colorset, c->name, c->fg, c->bg);
0812     }
0813 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!