1 /* ncmpc (Ncurses MPD Client)
2 * (c) 2004-2009 The Music Player Daemon Project
3 * Project homepage: http://musicpd.org
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
20 #include "list_window.h"
21 #include "config.h"
22 #include "options.h"
23 #include "charset.h"
24 #include "match.h"
25 #include "command.h"
26 #include "colors.h"
27 #include "screen_message.h"
28 #include "i18n.h"
30 #include <assert.h>
31 #include <stdlib.h>
32 #include <unistd.h>
33 #include <string.h>
35 extern void screen_bell(void);
37 struct list_window *
38 list_window_init(WINDOW *w, unsigned width, unsigned height)
39 {
40 struct list_window *lw;
42 lw = g_malloc0(sizeof(*lw));
43 lw->w = w;
44 lw->cols = width;
45 lw->rows = height;
46 lw->range_selection = false;
47 return lw;
48 }
50 void
51 list_window_free(struct list_window *lw)
52 {
53 assert(lw != NULL);
55 g_free(lw);
56 }
58 void
59 list_window_reset(struct list_window *lw)
60 {
61 lw->selected = 0;
62 lw->range_selection = false;
63 lw->range_base = 0;
64 lw->start = 0;
65 }
67 static unsigned
68 list_window_validate_index(const struct list_window *lw, unsigned i)
69 {
70 if (lw->length == 0)
71 return 0;
72 else if (i >= lw->length)
73 return lw->length - 1;
74 else
75 return i;
76 }
78 static void
79 list_window_check_selected(struct list_window *lw)
80 {
81 lw->selected = list_window_validate_index(lw, lw->selected);
83 if(lw->range_selection)
84 lw->range_base =
85 list_window_validate_index(lw, lw->range_base);
86 }
88 /**
89 * Scroll after the cursor was moved, the list was changed or the
90 * window was resized.
91 */
92 static void
93 list_window_check_origin(struct list_window *lw)
94 {
95 int start = lw->start;
97 if ((unsigned) options.scroll_offset * 2 >= lw->rows)
98 // Center if the offset is more than half the screen
99 start = lw->selected - lw->rows / 2;
100 else {
101 if (lw->selected < lw->start + options.scroll_offset)
102 start = lw->selected - options.scroll_offset;
104 if (lw->selected >= lw->start + lw->rows - options.scroll_offset)
105 start = lw->selected - lw->rows + 1 + options.scroll_offset;
106 }
108 if (start + lw->rows > lw->length)
109 start = lw->length - lw->rows;
111 if (start < 0 || lw->length == 0)
112 start = 0;
114 lw->start = start;
115 }
117 void
118 list_window_resize(struct list_window *lw, unsigned width, unsigned height)
119 {
120 lw->cols = width;
121 lw->rows = height;
123 list_window_check_origin(lw);
124 }
126 void
127 list_window_set_length(struct list_window *lw, unsigned length)
128 {
129 lw->length = length;
131 list_window_check_selected(lw);
132 list_window_check_origin(lw);
133 }
135 void
136 list_window_center(struct list_window *lw, unsigned n)
137 {
138 if (n > lw->rows / 2)
139 lw->start = n - lw->rows / 2;
140 else
141 lw->start = 0;
143 if (lw->start + lw->rows > lw->length) {
144 if (lw->rows < lw->length)
145 lw->start = lw->length - lw->rows;
146 else
147 lw->start = 0;
148 }
149 }
151 void
152 list_window_set_cursor(struct list_window *lw, unsigned i)
153 {
154 lw->range_selection = false;
155 lw->selected = i;
157 list_window_check_selected(lw);
158 list_window_check_origin(lw);
159 }
161 void
162 list_window_move_cursor(struct list_window *lw, unsigned n)
163 {
164 lw->selected = n;
166 list_window_check_selected(lw);
167 list_window_check_origin(lw);
168 }
170 void
171 list_window_fetch_cursor(struct list_window *lw)
172 {
173 if (lw->start > 0 &&
174 lw->selected < lw->start + options.scroll_offset)
175 list_window_move_cursor(lw, lw->start + options.scroll_offset);
176 else if (lw->start + lw->rows < lw->length &&
177 lw->selected > lw->start + lw->rows - 1 - options.scroll_offset)
178 list_window_move_cursor(lw, lw->start + lw->rows - 1 - options.scroll_offset);
179 }
181 void
182 list_window_get_range(const struct list_window *lw,
183 struct list_window_range *range)
184 {
185 if (lw->length == 0) {
186 /* empty list - no selection */
187 range->start = 0;
188 range->end = 0;
189 } else if (lw->range_selection) {
190 /* a range selection */
191 if (lw->range_base < lw->selected) {
192 range->start = lw->range_base;
193 range->end = lw->selected + 1;
194 } else {
195 range->start = lw->selected;
196 range->end = lw->range_base + 1;
197 }
198 } else {
199 /* no range, just the cursor */
200 range->start = lw->selected;
201 range->end = lw->selected + 1;
202 }
203 }
205 static void
206 list_window_next(struct list_window *lw)
207 {
208 if (lw->selected + 1 < lw->length)
209 list_window_move_cursor(lw, lw->selected + 1);
210 else if (options.list_wrap)
211 list_window_move_cursor(lw, 0);
212 }
214 static void
215 list_window_previous(struct list_window *lw)
216 {
217 if (lw->selected > 0)
218 list_window_move_cursor(lw, lw->selected - 1);
219 else if (options.list_wrap)
220 list_window_move_cursor(lw, lw->length - 1);
221 }
223 static void
224 list_window_top(struct list_window *lw)
225 {
226 if (lw->start == 0)
227 list_window_move_cursor(lw, lw->start);
228 else
229 if ((unsigned) options.scroll_offset * 2 >= lw->rows)
230 list_window_move_cursor(lw, lw->start + lw->rows / 2);
231 else
232 list_window_move_cursor(lw, lw->start + options.scroll_offset);
233 }
235 static void
236 list_window_middle(struct list_window *lw)
237 {
238 if (lw->length >= lw->rows)
239 list_window_move_cursor(lw, lw->start + lw->rows / 2);
240 else
241 list_window_move_cursor(lw, lw->length / 2);
242 }
244 static void
245 list_window_bottom(struct list_window *lw)
246 {
247 if (lw->length >= lw->rows)
248 if ((unsigned) options.scroll_offset * 2 >= lw->rows)
249 list_window_move_cursor(lw, lw->start + lw->rows / 2);
250 else
251 if (lw->start + lw->rows == lw->length)
252 list_window_move_cursor(lw, lw->length - 1);
253 else
254 list_window_move_cursor(lw, lw->start + lw->rows - 1 - options.scroll_offset);
255 else
256 list_window_move_cursor(lw, lw->length - 1);
257 }
259 static void
260 list_window_first(struct list_window *lw)
261 {
262 list_window_move_cursor(lw, 0);
263 }
265 static void
266 list_window_last(struct list_window *lw)
267 {
268 if (lw->length > 0)
269 list_window_move_cursor(lw, lw->length - 1);
270 else
271 list_window_move_cursor(lw, 0);
272 }
274 static void
275 list_window_next_page(struct list_window *lw)
276 {
277 if (lw->rows < 2)
278 return;
279 if (lw->selected + lw->rows < lw->length)
280 list_window_move_cursor(lw, lw->selected + lw->rows - 1);
281 else
282 list_window_last(lw);
283 }
285 static void
286 list_window_previous_page(struct list_window *lw)
287 {
288 if (lw->rows < 2)
289 return;
290 if (lw->selected > lw->rows - 1)
291 list_window_move_cursor(lw, lw->selected - lw->rows + 1);
292 else
293 list_window_first(lw);
294 }
296 static void
297 list_window_scroll_up(struct list_window *lw, unsigned n)
298 {
299 if (lw->start > 0) {
300 if (n > lw->start)
301 lw->start = 0;
302 else
303 lw->start -= n;
305 list_window_fetch_cursor(lw);
306 }
307 }
309 static void
310 list_window_scroll_down(struct list_window *lw, unsigned n)
311 {
312 if (lw->start + lw->rows < lw->length)
313 {
314 if ( lw->start + lw->rows + n > lw->length - 1)
315 lw->start = lw->length - lw->rows;
316 else
317 lw->start += n;
319 list_window_fetch_cursor(lw);
320 }
321 }
323 static void
324 list_window_paint_row(WINDOW *w, unsigned y, unsigned width,
325 bool selected, bool highlight,
326 const char *text, const char *second_column)
327 {
328 unsigned text_width = utf8_width(text);
329 unsigned second_column_width;
331 #ifdef NCMPC_MINI
332 second_column = NULL;
333 highlight = false;
334 #endif /* NCMPC_MINI */
336 if (second_column != NULL) {
337 second_column_width = utf8_width(second_column) + 1;
338 if (second_column_width < width)
339 width -= second_column_width;
340 else
341 second_column_width = 0;
342 } else
343 second_column_width = 0;
345 if (highlight)
346 colors_use(w, COLOR_LIST_BOLD);
347 else
348 colors_use(w, COLOR_LIST);
350 if (selected)
351 wattron(w, A_REVERSE);
353 waddstr(w, text);
354 if (options.wide_cursor && text_width < width)
355 whline(w, ' ', width - text_width);
357 if (second_column_width > 0) {
358 wmove(w, y, width);
359 waddch(w, ' ');
360 waddstr(w, second_column);
361 }
363 if (selected)
364 wattroff(w, A_REVERSE);
366 if (!options.wide_cursor && text_width < width) {
367 if (second_column_width == 0)
368 /* the cursor is at the end of the text; clear
369 the rest of this row */
370 wclrtoeol(w);
371 else
372 /* there's a second column: clear the space
373 between the first and the second column */
374 mvwhline(w, y, text_width, ' ', width - text_width);
375 }
376 }
378 void
379 list_window_paint(const struct list_window *lw,
380 list_window_callback_fn_t callback,
381 void *callback_data)
382 {
383 bool show_cursor = !lw->hide_cursor &&
384 (!options.hardware_cursor || lw->range_selection);
385 struct list_window_range range;
387 if (show_cursor)
388 list_window_get_range(lw, &range);
390 for (unsigned i = 0; i < lw->rows; i++) {
391 const char *label;
392 bool highlight = false;
393 char *second_column = NULL;
395 wmove(lw->w, i, 0);
397 if (lw->start + i >= lw->length) {
398 wclrtobot(lw->w);
399 break;
400 }
402 label = callback(lw->start + i, &highlight, &second_column, callback_data);
403 assert(label != NULL);
405 #ifdef NCMPC_MINI
406 highlight = false;
407 second_column = NULL;
408 #endif /* NCMPC_MINI */
410 list_window_paint_row(lw->w, i, lw->cols,
411 show_cursor &&
412 lw->start + i >= range.start &&
413 lw->start + i < range.end,
414 highlight,
415 label, second_column);
417 if (second_column != NULL)
418 g_free(second_column);
419 }
421 if (options.hardware_cursor && lw->selected >= lw->start &&
422 lw->selected < lw->start + lw->rows) {
423 curs_set(1);
424 wmove(lw->w, lw->selected - lw->start, 0);
425 }
426 }
428 bool
429 list_window_find(struct list_window *lw,
430 list_window_callback_fn_t callback,
431 void *callback_data,
432 const char *str,
433 bool wrap,
434 bool bell_on_wrap)
435 {
436 bool h;
437 unsigned i = lw->selected + 1;
438 const char *label;
440 assert(str != NULL);
442 do {
443 while (i < lw->length) {
444 label = callback(i, &h, NULL, callback_data);
445 assert(label != NULL);
447 if (match_line(label, str)) {
448 list_window_move_cursor(lw, i);
449 return true;
450 }
451 if (wrap && i == lw->selected)
452 return false;
453 i++;
454 }
455 if (wrap) {
456 if (i == 0) /* empty list */
457 return 1;
458 i=0; /* first item */
459 if (bell_on_wrap) {
460 screen_bell();
461 }
462 }
463 } while (wrap);
465 return false;
466 }
468 bool
469 list_window_rfind(struct list_window *lw,
470 list_window_callback_fn_t callback,
471 void *callback_data,
472 const char *str,
473 bool wrap,
474 bool bell_on_wrap)
475 {
476 bool h;
477 int i = lw->selected - 1;
478 const char *label;
480 assert(str != NULL);
482 if (lw->length == 0)
483 return false;
485 do {
486 while (i >= 0) {
487 label = callback(i, &h, NULL, callback_data);
488 assert(label != NULL);
490 if (match_line(label, str)) {
491 list_window_move_cursor(lw, i);
492 return true;
493 }
494 if (wrap && i == (int)lw->selected)
495 return false;
496 i--;
497 }
498 if (wrap) {
499 i = lw->length - 1; /* last item */
500 if (bell_on_wrap) {
501 screen_bell();
502 }
503 }
504 } while (wrap);
506 return false;
507 }
509 static bool
510 jump_match(const char *haystack, const char *needle)
511 {
512 #ifdef NCMPC_MINI
513 bool jump_prefix_only = true;
514 #else
515 bool jump_prefix_only = options.jump_prefix_only;
516 #endif
518 assert(haystack != NULL);
519 assert(needle != NULL);
521 return jump_prefix_only
522 ? g_ascii_strncasecmp(haystack, needle, strlen(needle)) == 0
523 : match_line(haystack, needle);
524 }
526 bool
527 list_window_jump(struct list_window *lw,
528 list_window_callback_fn_t callback,
529 void *callback_data,
530 const char *str)
531 {
532 bool h;
533 const char *label;
535 assert(str != NULL);
537 for (unsigned i = 0; i < lw->length; ++i) {
538 label = callback(i, &h, NULL, callback_data);
539 assert(label != NULL);
541 if (label[0] == '[')
542 label++;
544 if (jump_match(label, str)) {
545 list_window_move_cursor(lw, i);
546 return true;
547 }
548 }
549 return false;
550 }
552 /* perform basic list window commands (movement) */
553 bool
554 list_window_cmd(struct list_window *lw, command_t cmd)
555 {
556 switch (cmd) {
557 case CMD_LIST_PREVIOUS:
558 list_window_previous(lw);
559 break;
560 case CMD_LIST_NEXT:
561 list_window_next(lw);
562 break;
563 case CMD_LIST_TOP:
564 list_window_top(lw);
565 break;
566 case CMD_LIST_MIDDLE:
567 list_window_middle(lw);
568 break;
569 case CMD_LIST_BOTTOM:
570 list_window_bottom(lw);
571 break;
572 case CMD_LIST_FIRST:
573 list_window_first(lw);
574 break;
575 case CMD_LIST_LAST:
576 list_window_last(lw);
577 break;
578 case CMD_LIST_NEXT_PAGE:
579 list_window_next_page(lw);
580 break;
581 case CMD_LIST_PREVIOUS_PAGE:
582 list_window_previous_page(lw);
583 break;
584 case CMD_LIST_RANGE_SELECT:
585 if(lw->range_selection)
586 {
587 screen_status_printf(_("Range selection disabled"));
588 list_window_set_cursor(lw, lw->selected);
589 }
590 else
591 {
592 screen_status_printf(_("Range selection enabled"));
593 lw->range_base = lw->selected;
594 lw->range_selection = true;
595 }
596 break;
597 case CMD_LIST_SCROLL_UP_LINE:
598 list_window_scroll_up(lw, 1);
599 break;
600 case CMD_LIST_SCROLL_DOWN_LINE:
601 list_window_scroll_down(lw, 1);
602 break;
603 case CMD_LIST_SCROLL_UP_HALF:
604 list_window_scroll_up(lw, (lw->rows - 1) / 2);
605 break;
606 case CMD_LIST_SCROLL_DOWN_HALF:
607 list_window_scroll_down(lw, (lw->rows - 1) / 2);
608 break;
609 default:
610 return false;
611 }
613 return true;
614 }
616 bool
617 list_window_scroll_cmd(struct list_window *lw, command_t cmd)
618 {
619 switch (cmd) {
620 case CMD_LIST_SCROLL_UP_LINE:
621 case CMD_LIST_PREVIOUS:
622 if (lw->start > 0)
623 lw->start--;
624 break;
626 case CMD_LIST_SCROLL_DOWN_LINE:
627 case CMD_LIST_NEXT:
628 if (lw->start + lw->rows < lw->length)
629 lw->start++;
630 break;
632 case CMD_LIST_FIRST:
633 lw->start = 0;
634 break;
636 case CMD_LIST_LAST:
637 if (lw->length > lw->rows)
638 lw->start = lw->length - lw->rows;
639 else
640 lw->start = 0;
641 break;
643 case CMD_LIST_NEXT_PAGE:
644 lw->start += lw->rows - 1;
645 if (lw->start + lw->rows > lw->length) {
646 if (lw->length > lw->rows)
647 lw->start = lw->length - lw->rows;
648 else
649 lw->start = 0;
650 }
651 break;
653 case CMD_LIST_PREVIOUS_PAGE:
654 if (lw->start > lw->rows)
655 lw->start -= lw->rows;
656 else
657 lw->start = 0;
658 break;
660 case CMD_LIST_SCROLL_UP_HALF:
661 if (lw->start > (lw->rows - 1) / 2)
662 lw->start -= (lw->rows - 1) / 2;
663 else
664 lw->start = 0;
665 break;
667 case CMD_LIST_SCROLL_DOWN_HALF:
668 lw->start += (lw->rows - 1) / 2;
669 if (lw->start + lw->rows > lw->length) {
670 if (lw->length > lw->rows)
671 lw->start = lw->length - lw->rows;
672 else
673 lw->start = 0;
674 }
675 break;
677 default:
678 return false;
679 }
681 return true;
682 }
684 #ifdef HAVE_GETMOUSE
685 bool
686 list_window_mouse(struct list_window *lw, unsigned long bstate, int y)
687 {
688 assert(lw != NULL);
690 /* if the even occurred above the list window move up */
691 if (y < 0) {
692 if (bstate & BUTTON3_CLICKED)
693 list_window_first(lw);
694 else
695 list_window_previous_page(lw);
696 return true;
697 }
699 /* if the even occurred below the list window move down */
700 if ((unsigned)y >= lw->length) {
701 if (bstate & BUTTON3_CLICKED)
702 list_window_last(lw);
703 else
704 list_window_next_page(lw);
705 return true;
706 }
708 return false;
709 }
710 #endif