src/list_window.c

   1 /* ncmpc (Ncurses MPD Client)
   2  * (c) 2004-2009 The Music Player Daemon Project
   3  * Project homepage: http://musicpd.org
   4
   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.
   9
  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.
  14
  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 */
  19
  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"
  29
  30 #include <assert.h>
  31 #include <stdlib.h>
  32 #include <unistd.h>
  33 #include <string.h>
  34
  35 extern void screen_bell(void);
  36
  37 struct list_window *
  38 list_window_init(WINDOW *w, unsigned width, unsigned height)
  39 {
  40         struct list_window *lw;
  41
  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 }
  49
  50 void
  51 list_window_free(struct list_window *lw)
  52 {
  53         assert(lw != NULL);
  54
  55         g_free(lw);
  56 }
  57
  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 }
  66
  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 }
  77
  78 static void
  79 list_window_check_selected(struct list_window *lw)
  80 {
  81         lw->selected = list_window_validate_index(lw, lw->selected);
  82
  83         if(lw->range_selection)
  84                 lw->range_base =
  85                         list_window_validate_index(lw, lw->range_base);
  86 }
  87
  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;
  96
  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;
 103
 104                 if (lw->selected >= lw->start + lw->rows - options.scroll_offset)
 105                         start = lw->selected - lw->rows + 1 + options.scroll_offset;
 106         }
 107
 108         if (start + lw->rows > lw->length)
 109                 start = lw->length - lw->rows;
 110
 111         if (start < 0 || lw->length == 0)
 112                 start = 0;
 113
 114         lw->start = start;
 115 }
 116
 117 void
 118 list_window_resize(struct list_window *lw, unsigned width, unsigned height)
 119 {
 120         lw->cols = width;
 121         lw->rows = height;
 122
 123         list_window_check_origin(lw);
 124 }
 125
 126 void
 127 list_window_set_length(struct list_window *lw, unsigned length)
 128 {
 129         lw->length = length;
 130
 131         list_window_check_selected(lw);
 132         list_window_check_origin(lw);
 133 }
 134
 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;
 142
 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 }
 150
 151 void
 152 list_window_set_cursor(struct list_window *lw, unsigned i)
 153 {
 154         lw->range_selection = false;
 155         lw->selected = i;
 156
 157         list_window_check_selected(lw);
 158         list_window_check_origin(lw);
 159 }
 160
 161 void
 162 list_window_move_cursor(struct list_window *lw, unsigned n)
 163 {
 164         lw->selected = n;
 165
 166         list_window_check_selected(lw);
 167         list_window_check_origin(lw);
 168 }
 169
 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 }
 180
 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 }
 204
 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 }
 213
 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 }
 222
 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 }
 234
 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 }
 243
 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 }
 258
 259 static void
 260 list_window_first(struct list_window *lw)
 261 {
 262         list_window_move_cursor(lw, 0);
 263 }
 264
 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 }
 273
 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 }
 284
 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 }
 295
 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;
 304
 305                 list_window_fetch_cursor(lw);
 306         }
 307 }
 308
 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;
 318
 319                 list_window_fetch_cursor(lw);
 320         }
 321 }
 322
 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;
 330
 331 #ifdef NCMPC_MINI
 332         second_column = NULL;
 333         highlight = false;
 334 #endif /* NCMPC_MINI */
 335
 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;
 344
 345         if (highlight)
 346                 colors_use(w, COLOR_LIST_BOLD);
 347         else
 348                 colors_use(w, COLOR_LIST);
 349
 350         if (selected)
 351                 wattron(w, A_REVERSE);
 352
 353         waddstr(w, text);
 354         if (options.wide_cursor && text_width < width)
 355                 whline(w, ' ', width - text_width);
 356
 357         if (second_column_width > 0) {
 358                 wmove(w, y, width);
 359                 waddch(w, ' ');
 360                 waddstr(w, second_column);
 361         }
 362
 363         if (selected)
 364                 wattroff(w, A_REVERSE);
 365
 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 }
 377
 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;
 386
 387         if (show_cursor)
 388                 list_window_get_range(lw, &range);
 389
 390         for (unsigned i = 0; i < lw->rows; i++) {
 391                 const char *label;
 392                 bool highlight = false;
 393                 char *second_column = NULL;
 394
 395                 wmove(lw->w, i, 0);
 396
 397                 if (lw->start + i >= lw->length) {
 398                         wclrtobot(lw->w);
 399                         break;
 400                 }
 401
 402                 label = callback(lw->start + i, &highlight, &second_column, callback_data);
 403                 assert(label != NULL);
 404
 405 #ifdef NCMPC_MINI
 406                 highlight = false;
 407                 second_column = NULL;
 408 #endif /* NCMPC_MINI */
 409
 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);
 416
 417                 if (second_column != NULL)
 418                         g_free(second_column);
 419         }
 420
 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 }
 427
 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;
 439
 440         assert(str != NULL);
 441
 442         do {
 443                 while (i < lw->length) {
 444                         label = callback(i, &h, NULL, callback_data);
 445                         assert(label != NULL);
 446
 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);
 464
 465         return false;
 466 }
 467
 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;
 479
 480         assert(str != NULL);
 481
 482         if (lw->length == 0)
 483                 return false;
 484
 485         do {
 486                 while (i >= 0) {
 487                         label = callback(i, &h, NULL, callback_data);
 488                         assert(label != NULL);
 489
 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);
 505
 506         return false;
 507 }
 508
 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
 517
 518         assert(haystack != NULL);
 519         assert(needle != NULL);
 520
 521         return jump_prefix_only
 522                 ? g_ascii_strncasecmp(haystack, needle, strlen(needle)) == 0
 523                 : match_line(haystack, needle);
 524 }
 525
 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;
 534
 535         assert(str != NULL);
 536
 537         for (unsigned i = 0; i < lw->length; ++i) {
 538                 label = callback(i, &h, NULL, callback_data);
 539                 assert(label != NULL);
 540
 541                 if (label[0] == '[')
 542                         label++;
 543
 544                 if (jump_match(label, str)) {
 545                         list_window_move_cursor(lw, i);
 546                         return true;
 547                 }
 548         }
 549         return false;
 550 }
 551
 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         }
 612
 613         return true;
 614 }
 615
 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;
 625
 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;
 631
 632         case CMD_LIST_FIRST:
 633                 lw->start = 0;
 634                 break;
 635
 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;
 642
 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;
 652
 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;
 659
 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;
 666
 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;
 676
 677         default:
 678                 return false;
 679         }
 680
 681         return true;
 682 }
 683
 684 #ifdef HAVE_GETMOUSE
 685 bool
 686 list_window_mouse(struct list_window *lw, unsigned long bstate, int y)
 687 {
 688         assert(lw != NULL);
 689
 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         }
 698
 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         }
 707
 708         return false;
 709 }
 710 #endif