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
 355         /* erase the unused space after the text */
 356         if (text_width < width) {
 357                 if (options.wide_cursor)
 358                         whline(w, ' ', width - text_width);
 359                 else
 360                         wclrtoeol(w);
 361         }
 362
 363         if (second_column_width > 0) {
 364                 wmove(w, y, width);
 365                 waddch(w, ' ');
 366                 waddstr(w, second_column);
 367         }
 368
 369         if (selected)
 370                 wattroff(w, A_REVERSE);
 371 }
 372
 373 void
 374 list_window_paint(const struct list_window *lw,
 375                   list_window_callback_fn_t callback,
 376                   void *callback_data)
 377 {
 378         bool show_cursor = !lw->hide_cursor &&
 379                 (!options.hardware_cursor || lw->range_selection);
 380         struct list_window_range range;
 381
 382         if (show_cursor)
 383                 list_window_get_range(lw, &range);
 384
 385         for (unsigned i = 0; i < lw->rows; i++) {
 386                 const char *label;
 387                 bool highlight = false;
 388                 char *second_column = NULL;
 389
 390                 wmove(lw->w, i, 0);
 391
 392                 if (lw->start + i >= lw->length) {
 393                         wclrtobot(lw->w);
 394                         break;
 395                 }
 396
 397                 label = callback(lw->start + i, &highlight, &second_column, callback_data);
 398                 assert(label != NULL);
 399
 400 #ifdef NCMPC_MINI
 401                 highlight = false;
 402                 second_column = NULL;
 403 #endif /* NCMPC_MINI */
 404
 405                 list_window_paint_row(lw->w, i, lw->cols,
 406                                       show_cursor &&
 407                                       lw->start + i >= range.start &&
 408                                       lw->start + i < range.end,
 409                                       highlight,
 410                                       label, second_column);
 411
 412                 if (second_column != NULL)
 413                         g_free(second_column);
 414         }
 415
 416         if (options.hardware_cursor && lw->selected >= lw->start &&
 417             lw->selected < lw->start + lw->rows) {
 418                 curs_set(1);
 419                 wmove(lw->w, lw->selected - lw->start, 0);
 420         }
 421 }
 422
 423 bool
 424 list_window_find(struct list_window *lw,
 425                  list_window_callback_fn_t callback,
 426                  void *callback_data,
 427                  const char *str,
 428                  bool wrap,
 429                  bool bell_on_wrap)
 430 {
 431         bool h;
 432         unsigned i = lw->selected + 1;
 433         const char *label;
 434
 435         assert(str != NULL);
 436
 437         do {
 438                 while (i < lw->length) {
 439                         label = callback(i, &h, NULL, callback_data);
 440                         assert(label != NULL);
 441
 442                         if (match_line(label, str)) {
 443                                 list_window_move_cursor(lw, i);
 444                                 return true;
 445                         }
 446                         if (wrap && i == lw->selected)
 447                                 return false;
 448                         i++;
 449                 }
 450                 if (wrap) {
 451                         if (i == 0) /* empty list */
 452                                 return 1;
 453                         i=0; /* first item */
 454                         if (bell_on_wrap) {
 455                                 screen_bell();
 456                         }
 457                 }
 458         } while (wrap);
 459
 460         return false;
 461 }
 462
 463 bool
 464 list_window_rfind(struct list_window *lw,
 465                   list_window_callback_fn_t callback,
 466                   void *callback_data,
 467                   const char *str,
 468                   bool wrap,
 469                   bool bell_on_wrap)
 470 {
 471         bool h;
 472         int i = lw->selected - 1;
 473         const char *label;
 474
 475         assert(str != NULL);
 476
 477         if (lw->length == 0)
 478                 return false;
 479
 480         do {
 481                 while (i >= 0) {
 482                         label = callback(i, &h, NULL, callback_data);
 483                         assert(label != NULL);
 484
 485                         if (match_line(label, str)) {
 486                                 list_window_move_cursor(lw, i);
 487                                 return true;
 488                         }
 489                         if (wrap && i == (int)lw->selected)
 490                                 return false;
 491                         i--;
 492                 }
 493                 if (wrap) {
 494                         i = lw->length - 1; /* last item */
 495                         if (bell_on_wrap) {
 496                                 screen_bell();
 497                         }
 498                 }
 499         } while (wrap);
 500
 501         return false;
 502 }
 503
 504 static bool
 505 jump_match(const char *haystack, const char *needle)
 506 {
 507 #ifdef NCMPC_MINI
 508         bool jump_prefix_only = true;
 509 #else
 510         bool jump_prefix_only = options.jump_prefix_only;
 511 #endif
 512
 513         assert(haystack != NULL);
 514         assert(needle != NULL);
 515
 516         return jump_prefix_only
 517                 ? g_ascii_strncasecmp(haystack, needle, strlen(needle)) == 0
 518                 : match_line(haystack, needle);
 519 }
 520
 521 bool
 522 list_window_jump(struct list_window *lw,
 523                  list_window_callback_fn_t callback,
 524                  void *callback_data,
 525                  const char *str)
 526 {
 527         bool h;
 528         const char *label;
 529
 530         assert(str != NULL);
 531
 532         for (unsigned i = 0; i < lw->length; ++i) {
 533                 label = callback(i, &h, NULL, callback_data);
 534                 assert(label != NULL);
 535
 536                 if (label[0] == '[')
 537                         label++;
 538
 539                 if (jump_match(label, str)) {
 540                         list_window_move_cursor(lw, i);
 541                         return true;
 542                 }
 543         }
 544         return false;
 545 }
 546
 547 /* perform basic list window commands (movement) */
 548 bool
 549 list_window_cmd(struct list_window *lw, command_t cmd)
 550 {
 551         switch (cmd) {
 552         case CMD_LIST_PREVIOUS:
 553                 list_window_previous(lw);
 554                 break;
 555         case CMD_LIST_NEXT:
 556                 list_window_next(lw);
 557                 break;
 558         case CMD_LIST_TOP:
 559                 list_window_top(lw);
 560                 break;
 561         case CMD_LIST_MIDDLE:
 562                 list_window_middle(lw);
 563                 break;
 564         case CMD_LIST_BOTTOM:
 565                 list_window_bottom(lw);
 566                 break;
 567         case CMD_LIST_FIRST:
 568                 list_window_first(lw);
 569                 break;
 570         case CMD_LIST_LAST:
 571                 list_window_last(lw);
 572                 break;
 573         case CMD_LIST_NEXT_PAGE:
 574                 list_window_next_page(lw);
 575                 break;
 576         case CMD_LIST_PREVIOUS_PAGE:
 577                 list_window_previous_page(lw);
 578                 break;
 579         case CMD_LIST_RANGE_SELECT:
 580                 if(lw->range_selection)
 581                 {
 582                         screen_status_printf(_("Range selection disabled"));
 583                         list_window_set_cursor(lw, lw->selected);
 584                 }
 585                 else
 586                 {
 587                         screen_status_printf(_("Range selection enabled"));
 588                         lw->range_base = lw->selected;
 589                         lw->range_selection = true;
 590                 }
 591                 break;
 592         case CMD_LIST_SCROLL_UP_LINE:
 593                 list_window_scroll_up(lw, 1);
 594                 break;
 595         case CMD_LIST_SCROLL_DOWN_LINE:
 596                 list_window_scroll_down(lw, 1);
 597                 break;
 598         case CMD_LIST_SCROLL_UP_HALF:
 599                 list_window_scroll_up(lw, (lw->rows - 1) / 2);
 600                 break;
 601         case CMD_LIST_SCROLL_DOWN_HALF:
 602                 list_window_scroll_down(lw, (lw->rows - 1) / 2);
 603                 break;
 604         default:
 605                 return false;
 606         }
 607
 608         return true;
 609 }
 610
 611 bool
 612 list_window_scroll_cmd(struct list_window *lw, command_t cmd)
 613 {
 614         switch (cmd) {
 615         case CMD_LIST_SCROLL_UP_LINE:
 616         case CMD_LIST_PREVIOUS:
 617                 if (lw->start > 0)
 618                         lw->start--;
 619                 break;
 620
 621         case CMD_LIST_SCROLL_DOWN_LINE:
 622         case CMD_LIST_NEXT:
 623                 if (lw->start + lw->rows < lw->length)
 624                         lw->start++;
 625                 break;
 626
 627         case CMD_LIST_FIRST:
 628                 lw->start = 0;
 629                 break;
 630
 631         case CMD_LIST_LAST:
 632                 if (lw->length > lw->rows)
 633                         lw->start = lw->length - lw->rows;
 634                 else
 635                         lw->start = 0;
 636                 break;
 637
 638         case CMD_LIST_NEXT_PAGE:
 639                 lw->start += lw->rows - 1;
 640                 if (lw->start + lw->rows > lw->length) {
 641                         if (lw->length > lw->rows)
 642                                 lw->start = lw->length - lw->rows;
 643                         else
 644                                 lw->start = 0;
 645                 }
 646                 break;
 647
 648         case CMD_LIST_PREVIOUS_PAGE:
 649                 if (lw->start > lw->rows)
 650                         lw->start -= lw->rows;
 651                 else
 652                         lw->start = 0;
 653                 break;
 654
 655         case CMD_LIST_SCROLL_UP_HALF:
 656                 if (lw->start > (lw->rows - 1) / 2)
 657                         lw->start -= (lw->rows - 1) / 2;
 658                 else
 659                         lw->start = 0;
 660                 break;
 661
 662         case CMD_LIST_SCROLL_DOWN_HALF:
 663                 lw->start += (lw->rows - 1) / 2;
 664                 if (lw->start + lw->rows > lw->length) {
 665                         if (lw->length > lw->rows)
 666                                 lw->start = lw->length - lw->rows;
 667                         else
 668                                 lw->start = 0;
 669                 }
 670                 break;
 671
 672         default:
 673                 return false;
 674         }
 675
 676         return true;
 677 }
 678
 679 #ifdef HAVE_GETMOUSE
 680 bool
 681 list_window_mouse(struct list_window *lw, unsigned long bstate, int y)
 682 {
 683         assert(lw != NULL);
 684
 685         /* if the even occurred above the list window move up */
 686         if (y < 0) {
 687                 if (bstate & BUTTON3_CLICKED)
 688                         list_window_first(lw);
 689                 else
 690                         list_window_previous_page(lw);
 691                 return true;
 692         }
 693
 694         /* if the even occurred below the list window move down */
 695         if ((unsigned)y >= lw->length) {
 696                 if (bstate & BUTTON3_CLICKED)
 697                         list_window_last(lw);
 698                 else
 699                         list_window_next_page(lw);
 700                 return true;
 701         }
 702
 703         return false;
 704 }
 705 #endif