src/list_window.c

   1 /* ncmpc (Ncurses MPD Client)
   2  * (c) 2004-2010 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 "paint.h"
  28 #include "screen_message.h"
  29 #include "i18n.h"
  30
  31 #include <assert.h>
  32 #include <stdlib.h>
  33 #include <unistd.h>
  34 #include <string.h>
  35
  36 extern void screen_bell(void);
  37
  38 struct list_window *
  39 list_window_init(WINDOW *w, unsigned width, unsigned height)
  40 {
  41         struct list_window *lw;
  42
  43         lw = g_malloc0(sizeof(*lw));
  44         lw->w = w;
  45         lw->cols = width;
  46         lw->rows = height;
  47         lw->range_selection = false;
  48         return lw;
  49 }
  50
  51 void
  52 list_window_free(struct list_window *lw)
  53 {
  54         assert(lw != NULL);
  55
  56         g_free(lw);
  57 }
  58
  59 void
  60 list_window_reset(struct list_window *lw)
  61 {
  62         lw->selected = 0;
  63         lw->range_selection = false;
  64         lw->range_base = 0;
  65         lw->start = 0;
  66 }
  67
  68 static unsigned
  69 list_window_validate_index(const struct list_window *lw, unsigned i)
  70 {
  71         if (lw->length == 0)
  72                 return 0;
  73         else if (i >= lw->length)
  74                 return lw->length - 1;
  75         else
  76                 return i;
  77 }
  78
  79 static void
  80 list_window_check_selected(struct list_window *lw)
  81 {
  82         lw->selected = list_window_validate_index(lw, lw->selected);
  83
  84         if(lw->range_selection)
  85                 lw->range_base =
  86                         list_window_validate_index(lw, lw->range_base);
  87 }
  88
  89 /**
  90  * Scroll after the cursor was moved, the list was changed or the
  91  * window was resized.
  92  */
  93 static void
  94 list_window_check_origin(struct list_window *lw)
  95 {
  96         int start = lw->start;
  97
  98         if ((unsigned) options.scroll_offset * 2 >= lw->rows)
  99                 // Center if the offset is more than half the screen
 100                 start = lw->selected - lw->rows / 2;
 101         else {
 102                 if (lw->selected < lw->start + options.scroll_offset)
 103                         start = lw->selected - options.scroll_offset;
 104
 105                 if (lw->selected >= lw->start + lw->rows - options.scroll_offset)
 106                         start = lw->selected - lw->rows + 1 + options.scroll_offset;
 107         }
 108
 109         if (start + lw->rows > lw->length)
 110                 start = lw->length - lw->rows;
 111
 112         if (start < 0 || lw->length == 0)
 113                 start = 0;
 114
 115         lw->start = start;
 116 }
 117
 118 void
 119 list_window_resize(struct list_window *lw, unsigned width, unsigned height)
 120 {
 121         lw->cols = width;
 122         lw->rows = height;
 123
 124         list_window_check_origin(lw);
 125 }
 126
 127 void
 128 list_window_set_length(struct list_window *lw, unsigned length)
 129 {
 130         if (length == lw->length)
 131                 return;
 132
 133         lw->length = length;
 134
 135         list_window_check_selected(lw);
 136         list_window_check_origin(lw);
 137 }
 138
 139 void
 140 list_window_center(struct list_window *lw, unsigned n)
 141 {
 142         if (n > lw->rows / 2)
 143                 lw->start = n - lw->rows / 2;
 144         else
 145                 lw->start = 0;
 146
 147         if (lw->start + lw->rows > lw->length) {
 148                 if (lw->rows < lw->length)
 149                         lw->start = lw->length - lw->rows;
 150                 else
 151                         lw->start = 0;
 152         }
 153 }
 154
 155 void
 156 list_window_set_cursor(struct list_window *lw, unsigned i)
 157 {
 158         lw->range_selection = false;
 159         lw->selected = i;
 160
 161         list_window_check_selected(lw);
 162         list_window_check_origin(lw);
 163 }
 164
 165 void
 166 list_window_move_cursor(struct list_window *lw, unsigned n)
 167 {
 168         lw->selected = n;
 169
 170         list_window_check_selected(lw);
 171         list_window_check_origin(lw);
 172 }
 173
 174 void
 175 list_window_fetch_cursor(struct list_window *lw)
 176 {
 177         if (lw->start > 0 &&
 178             lw->selected < lw->start + options.scroll_offset)
 179                 list_window_move_cursor(lw, lw->start + options.scroll_offset);
 180         else if (lw->start + lw->rows < lw->length &&
 181                  lw->selected > lw->start + lw->rows - 1 - options.scroll_offset)
 182                 list_window_move_cursor(lw, lw->start + lw->rows - 1 - options.scroll_offset);
 183 }
 184
 185 void
 186 list_window_get_range(const struct list_window *lw,
 187                       struct list_window_range *range)
 188 {
 189         if (lw->length == 0) {
 190                 /* empty list - no selection */
 191                 range->start = 0;
 192                 range->end = 0;
 193         } else if (lw->range_selection) {
 194                 /* a range selection */
 195                 if (lw->range_base < lw->selected) {
 196                         range->start = lw->range_base;
 197                         range->end = lw->selected + 1;
 198                 } else {
 199                         range->start = lw->selected;
 200                         range->end = lw->range_base + 1;
 201                 }
 202         } else {
 203                 /* no range, just the cursor */
 204                 range->start = lw->selected;
 205                 range->end = lw->selected + 1;
 206         }
 207 }
 208
 209 static void
 210 list_window_next(struct list_window *lw)
 211 {
 212         if (lw->selected + 1 < lw->length)
 213                 list_window_move_cursor(lw, lw->selected + 1);
 214         else if (options.list_wrap)
 215                 list_window_move_cursor(lw, 0);
 216 }
 217
 218 static void
 219 list_window_previous(struct list_window *lw)
 220 {
 221         if (lw->selected > 0)
 222                 list_window_move_cursor(lw, lw->selected - 1);
 223         else if (options.list_wrap)
 224                 list_window_move_cursor(lw, lw->length - 1);
 225 }
 226
 227 static void
 228 list_window_top(struct list_window *lw)
 229 {
 230         if (lw->start == 0)
 231                 list_window_move_cursor(lw, lw->start);
 232         else
 233                 if ((unsigned) options.scroll_offset * 2 >= lw->rows)
 234                         list_window_move_cursor(lw, lw->start + lw->rows / 2);
 235                 else
 236                         list_window_move_cursor(lw, lw->start + options.scroll_offset);
 237 }
 238
 239 static void
 240 list_window_middle(struct list_window *lw)
 241 {
 242         if (lw->length >= lw->rows)
 243                 list_window_move_cursor(lw, lw->start + lw->rows / 2);
 244         else
 245                 list_window_move_cursor(lw, lw->length / 2);
 246 }
 247
 248 static void
 249 list_window_bottom(struct list_window *lw)
 250 {
 251         if (lw->length >= lw->rows)
 252                 if ((unsigned) options.scroll_offset * 2 >= lw->rows)
 253                         list_window_move_cursor(lw, lw->start + lw->rows / 2);
 254                 else
 255                         if (lw->start + lw->rows == lw->length)
 256                                 list_window_move_cursor(lw, lw->length - 1);
 257                         else
 258                                 list_window_move_cursor(lw, lw->start + lw->rows - 1 - options.scroll_offset);
 259         else
 260                 list_window_move_cursor(lw, lw->length - 1);
 261 }
 262
 263 static void
 264 list_window_first(struct list_window *lw)
 265 {
 266         list_window_move_cursor(lw, 0);
 267 }
 268
 269 static void
 270 list_window_last(struct list_window *lw)
 271 {
 272         if (lw->length > 0)
 273                 list_window_move_cursor(lw, lw->length - 1);
 274         else
 275                 list_window_move_cursor(lw, 0);
 276 }
 277
 278 static void
 279 list_window_next_page(struct list_window *lw)
 280 {
 281         if (lw->rows < 2)
 282                 return;
 283         if (lw->selected + lw->rows < lw->length)
 284                 list_window_move_cursor(lw, lw->selected + lw->rows - 1);
 285         else
 286                 list_window_last(lw);
 287 }
 288
 289 static void
 290 list_window_previous_page(struct list_window *lw)
 291 {
 292         if (lw->rows < 2)
 293                 return;
 294         if (lw->selected > lw->rows - 1)
 295                 list_window_move_cursor(lw, lw->selected - lw->rows + 1);
 296         else
 297                 list_window_first(lw);
 298 }
 299
 300 static void
 301 list_window_scroll_up(struct list_window *lw, unsigned n)
 302 {
 303         if (lw->start > 0) {
 304                 if (n > lw->start)
 305                         lw->start = 0;
 306                 else
 307                         lw->start -= n;
 308
 309                 list_window_fetch_cursor(lw);
 310         }
 311 }
 312
 313 static void
 314 list_window_scroll_down(struct list_window *lw, unsigned n)
 315 {
 316         if (lw->start + lw->rows < lw->length)
 317         {
 318                 if ( lw->start + lw->rows + n > lw->length - 1)
 319                         lw->start = lw->length - lw->rows;
 320                 else
 321                         lw->start += n;
 322
 323                 list_window_fetch_cursor(lw);
 324         }
 325 }
 326
 327 static void
 328 list_window_paint_row(WINDOW *w, unsigned width, bool selected,
 329                       const char *text)
 330 {
 331         row_paint_text(w, width, COLOR_LIST,
 332                        selected, text);
 333 }
 334
 335 void
 336 list_window_paint(const struct list_window *lw,
 337                   list_window_callback_fn_t callback,
 338                   void *callback_data)
 339 {
 340         bool show_cursor = !lw->hide_cursor &&
 341                 (!options.hardware_cursor || lw->range_selection);
 342         struct list_window_range range;
 343
 344         if (show_cursor)
 345                 list_window_get_range(lw, &range);
 346
 347         for (unsigned i = 0; i < lw->rows; i++) {
 348                 const char *label;
 349
 350                 wmove(lw->w, i, 0);
 351
 352                 if (lw->start + i >= lw->length) {
 353                         wclrtobot(lw->w);
 354                         break;
 355                 }
 356
 357                 label = callback(lw->start + i, callback_data);
 358                 assert(label != NULL);
 359
 360                 list_window_paint_row(lw->w, lw->cols,
 361                                       show_cursor &&
 362                                       lw->start + i >= range.start &&
 363                                       lw->start + i < range.end,
 364                                       label);
 365         }
 366
 367         row_color_end(lw->w);
 368
 369         if (options.hardware_cursor && lw->selected >= lw->start &&
 370             lw->selected < lw->start + lw->rows) {
 371                 curs_set(1);
 372                 wmove(lw->w, lw->selected - lw->start, 0);
 373         }
 374 }
 375
 376 void
 377 list_window_paint2(const struct list_window *lw,
 378                    list_window_paint_callback_t paint_callback,
 379                    void *callback_data)
 380 {
 381         bool show_cursor = !lw->hide_cursor &&
 382                 (!options.hardware_cursor || lw->range_selection);
 383         struct list_window_range range;
 384
 385         if (show_cursor)
 386                 list_window_get_range(lw, &range);
 387
 388         for (unsigned i = 0; i < lw->rows; i++) {
 389                 bool selected;
 390
 391                 wmove(lw->w, i, 0);
 392
 393                 if (lw->start + i >= lw->length) {
 394                         wclrtobot(lw->w);
 395                         break;
 396                 }
 397
 398                 selected = show_cursor &&
 399                         lw->start + i >= range.start &&
 400                         lw->start + i < range.end;
 401
 402                 paint_callback(lw->w, lw->start + i, i, lw->cols,
 403                                selected, callback_data);
 404         }
 405
 406         if (options.hardware_cursor && lw->selected >= lw->start &&
 407             lw->selected < lw->start + lw->rows) {
 408                 curs_set(1);
 409                 wmove(lw->w, lw->selected - lw->start, 0);
 410         }
 411 }
 412
 413 bool
 414 list_window_find(struct list_window *lw,
 415                  list_window_callback_fn_t callback,
 416                  void *callback_data,
 417                  const char *str,
 418                  bool wrap,
 419                  bool bell_on_wrap)
 420 {
 421         unsigned i = lw->selected + 1;
 422         const char *label;
 423
 424         assert(str != NULL);
 425
 426         do {
 427                 while (i < lw->length) {
 428                         label = callback(i, callback_data);
 429                         assert(label != NULL);
 430
 431                         if (match_line(label, str)) {
 432                                 list_window_move_cursor(lw, i);
 433                                 return true;
 434                         }
 435                         if (wrap && i == lw->selected)
 436                                 return false;
 437                         i++;
 438                 }
 439                 if (wrap) {
 440                         if (i == 0) /* empty list */
 441                                 return 1;
 442                         i=0; /* first item */
 443                         if (bell_on_wrap) {
 444                                 screen_bell();
 445                         }
 446                 }
 447         } while (wrap);
 448
 449         return false;
 450 }
 451
 452 bool
 453 list_window_rfind(struct list_window *lw,
 454                   list_window_callback_fn_t callback,
 455                   void *callback_data,
 456                   const char *str,
 457                   bool wrap,
 458                   bool bell_on_wrap)
 459 {
 460         int i = lw->selected - 1;
 461         const char *label;
 462
 463         assert(str != NULL);
 464
 465         if (lw->length == 0)
 466                 return false;
 467
 468         do {
 469                 while (i >= 0) {
 470                         label = callback(i, callback_data);
 471                         assert(label != NULL);
 472
 473                         if (match_line(label, str)) {
 474                                 list_window_move_cursor(lw, i);
 475                                 return true;
 476                         }
 477                         if (wrap && i == (int)lw->selected)
 478                                 return false;
 479                         i--;
 480                 }
 481                 if (wrap) {
 482                         i = lw->length - 1; /* last item */
 483                         if (bell_on_wrap) {
 484                                 screen_bell();
 485                         }
 486                 }
 487         } while (wrap);
 488
 489         return false;
 490 }
 491
 492 #ifdef NCMPC_MINI
 493 bool
 494 list_window_jump(struct list_window *lw,
 495                  list_window_callback_fn_t callback,
 496                  void *callback_data,
 497                  const char *str)
 498 {
 499         unsigned i;
 500         const char *label;
 501
 502         assert(str != NULL);
 503
 504         for (i = 0; i < lw->length; i++) {
 505                 label = callback(i, callback_data);
 506                 assert(label != NULL);
 507
 508                 if (g_ascii_strncasecmp(label, str, strlen(str)) == 0) {
 509                         list_window_move_cursor(lw, i);
 510                         return true;
 511                 }
 512         }
 513         return false;
 514 }
 515 #else
 516 bool
 517 list_window_jump(struct list_window *lw,
 518                  list_window_callback_fn_t callback,
 519                  void *callback_data,
 520                  const char *str)
 521 {
 522         unsigned i;
 523         const char *label;
 524         GRegex *regex;
 525
 526         assert(str != NULL);
 527
 528         regex = compile_regex(str, options.jump_prefix_only);
 529         if (regex == NULL)
 530                 return false;
 531
 532         for (i = 0; i < lw->length; i++) {
 533                 label = callback(i, callback_data);
 534                 assert(label != NULL);
 535
 536                 if (match_regex(regex, label)) {
 537                         g_regex_unref(regex);
 538                         list_window_move_cursor(lw, i);
 539                         return true;
 540                 }
 541         }
 542         g_regex_unref(regex);
 543         return false;
 544 }
 545 #endif
 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