src/viewer/move.c

   1 /*
   2    Internal file viewer for the Midnight Commander
   3    Functions for handle cursor movement
   4
   5    Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
   6    2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
   7
   8    Written by: 1994, 1995, 1998 Miguel de Icaza
   9    1994, 1995 Janne Kukonlehto
  10    1995 Jakub Jelinek
  11    1996 Joseph M. Hinkle
  12    1997 Norbert Warmuth
  13    1998 Pavel Machek
  14    2004 Roland Illig <roland.illig@gmx.de>
  15    2005 Roland Illig <roland.illig@gmx.de>
  16    2009 Slava Zanko <slavazanko@google.com>
  17    2009 Andrew Borodin <aborodin@vmail.ru>
  18    2009, 2010 Ilia Maslakov <il.smind@gmail.com>
  19
  20    This file is part of the Midnight Commander.
  21
  22    The Midnight Commander is free software; you can redistribute it
  23    and/or modify it under the terms of the GNU General Public License as
  24    published by the Free Software Foundation; either version 2 of the
  25    License, or (at your option) any later version.
  26
  27    The Midnight Commander is distributed in the hope that it will be
  28    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  29    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  30    General Public License for more details.
  31
  32    You should have received a copy of the GNU General Public License
  33    along with this program; if not, write to the Free Software
  34    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  35    MA 02110-1301, USA.
  36  */
  37
  38 /*
  39    The following variables have to do with the current position and are
  40    updated by the cursor movement functions.
  41
  42    In hex view and wrapped text view mode, dpy_start marks the offset of
  43    the top-left corner on the screen, in non-wrapping text mode it is
  44    the beginning of the current line.  In hex mode, hex_cursor is the
  45    offset of the cursor.  In non-wrapping text mode, dpy_text_column is
  46    the number of columns that are hidden on the left side on the screen.
  47
  48    In hex mode, dpy_start is updated by the view_fix_cursor_position()
  49    function in order to keep the other functions simple.  In
  50    non-wrapping text mode dpy_start and dpy_text_column are normalized
  51    such that dpy_text_column < view_get_datacolumns().
  52  */
  53
  54 #include <config.h>
  55
  56 #include "lib/global.h"
  57 #include "lib/tty/tty.h"
  58 #include "internal.h"
  59
  60 /*** global variables ****************************************************************************/
  61
  62 /*** file scope macro definitions ****************************************************************/
  63
  64 /*** file scope type declarations ****************************************************************/
  65
  66 /*** file scope variables ************************************************************************/
  67
  68 /*** file scope functions ************************************************************************/
  69 /* --------------------------------------------------------------------------------------------- */
  70
  71 static void
  72 mcview_movement_fixups (mcview_t * view, gboolean reset_search)
  73 {
  74     mcview_scroll_to_cursor (view);
  75     if (reset_search)
  76     {
  77         view->search_start = view->dpy_start;
  78         view->search_end = view->dpy_start;
  79     }
  80     view->dirty++;
  81 }
  82
  83 /* --------------------------------------------------------------------------------------------- */
  84 /*** public functions ****************************************************************************/
  85 /* --------------------------------------------------------------------------------------------- */
  86
  87 void
  88 mcview_move_up (mcview_t * view, off_t lines)
  89 {
  90     off_t new_offset;
  91
  92     if (view->hex_mode)
  93     {
  94         off_t bytes = lines * view->bytes_per_line;
  95         if (view->hex_cursor >= bytes)
  96         {
  97             view->hex_cursor -= bytes;
  98             if (view->hex_cursor < view->dpy_start)
  99                 view->dpy_start = mcview_offset_doz (view->dpy_start, bytes);
 100         }
 101         else
 102         {
 103             view->hex_cursor %= view->bytes_per_line;
 104         }
 105     }
 106     else
 107     {
 108         off_t i;
 109
 110         for (i = 0; i < lines; i++)
 111         {
 112             if (view->dpy_start == 0)
 113                 break;
 114             if (view->text_wrap_mode)
 115             {
 116                 new_offset = mcview_bol (view, view->dpy_start, view->dpy_start - (off_t) 1);
 117                 /* check if dpy_start == BOL or not (then new_offset = dpy_start - 1,
 118                  * no need to check more) */
 119                 if (new_offset == view->dpy_start)
 120                 {
 121                     size_t last_row_length;
 122
 123                     new_offset = mcview_bol (view, new_offset - 1, 0);
 124                     last_row_length = (view->dpy_start - new_offset) % view->data_area.width;
 125                     if (last_row_length != 0)
 126                     {
 127                         /* if dpy_start == BOL in wrapped mode, find BOL of previous line
 128                          * and move down all but the last rows */
 129                         new_offset = view->dpy_start - (off_t) last_row_length;
 130                     }
 131                 }
 132                 else
 133                 {
 134                     /* if dpy_start != BOL in wrapped mode, just move one row up;
 135                      * no need to check if > 0 as there is at least exactly one wrap
 136                      * between dpy_start and BOL */
 137                     new_offset = view->dpy_start - (off_t) view->data_area.width;
 138                 }
 139                 view->dpy_start = new_offset;
 140             }
 141             else
 142             {
 143                 /* if unwrapped -> current BOL equals dpy_start, just find BOL of previous line */
 144                 new_offset = view->dpy_start - 1;
 145                 view->dpy_start = mcview_bol (view, new_offset, 0);
 146             }
 147         }
 148     }
 149     mcview_movement_fixups (view, TRUE);
 150 }
 151
 152 /* --------------------------------------------------------------------------------------------- */
 153
 154 void
 155 mcview_move_down (mcview_t * view, off_t lines)
 156 {
 157     off_t last_byte;
 158     last_byte = mcview_get_filesize (view);
 159     if (view->hex_mode)
 160     {
 161         off_t i, limit;
 162
 163         if (last_byte >= (off_t) view->bytes_per_line)
 164             limit = last_byte - view->bytes_per_line;
 165         else
 166             limit = 0;
 167         for (i = 0; i < lines && view->hex_cursor < limit; i++)
 168         {
 169             view->hex_cursor += view->bytes_per_line;
 170             if (lines != 1)
 171                 view->dpy_start += view->bytes_per_line;
 172         }
 173     }
 174     else
 175     {
 176         off_t new_offset = 0;
 177
 178         if (view->dpy_end - view->dpy_start > last_byte - view->dpy_end)
 179         {
 180             while (lines-- > 0)
 181             {
 182                 if (view->text_wrap_mode)
 183                     view->dpy_end =
 184                         mcview_eol (view, view->dpy_end,
 185                                     view->dpy_end + (off_t) view->data_area.width);
 186                 else
 187                     view->dpy_end = mcview_eol (view, view->dpy_end, last_byte);
 188
 189                 if (view->text_wrap_mode)
 190                     new_offset =
 191                         mcview_eol (view, view->dpy_start,
 192                                     view->dpy_start + (off_t) view->data_area.width);
 193                 else
 194                     new_offset = mcview_eol (view, view->dpy_start, last_byte);
 195                 if (new_offset < last_byte)
 196                     view->dpy_start = new_offset;
 197                 if (view->dpy_end >= last_byte)
 198                     break;
 199             }
 200         }
 201         else
 202         {
 203             off_t i;
 204             for (i = 0; i < lines && new_offset < last_byte; i++)
 205             {
 206                 if (view->text_wrap_mode)
 207                     new_offset =
 208                         mcview_eol (view, view->dpy_start,
 209                                     view->dpy_start + (off_t) view->data_area.width);
 210                 else
 211                     new_offset = mcview_eol (view, view->dpy_start, last_byte);
 212                 if (new_offset < last_byte)
 213                     view->dpy_start = new_offset;
 214             }
 215         }
 216     }
 217     mcview_movement_fixups (view, TRUE);
 218 }
 219
 220 /* --------------------------------------------------------------------------------------------- */
 221
 222 void
 223 mcview_move_left (mcview_t * view, off_t columns)
 224 {
 225     if (view->hex_mode)
 226     {
 227         off_t old_cursor = view->hex_cursor;
 228         assert (columns == 1);
 229         if (view->hexview_in_text || !view->hexedit_lownibble)
 230         {
 231             if (view->hex_cursor > 0)
 232                 view->hex_cursor--;
 233         }
 234         if (!view->hexview_in_text)
 235             if (old_cursor > 0 || view->hexedit_lownibble)
 236                 view->hexedit_lownibble = !view->hexedit_lownibble;
 237     }
 238     else
 239     {
 240         if (view->dpy_text_column >= columns)
 241             view->dpy_text_column -= columns;
 242         else
 243             view->dpy_text_column = 0;
 244     }
 245     mcview_movement_fixups (view, FALSE);
 246 }
 247
 248 /* --------------------------------------------------------------------------------------------- */
 249
 250 void
 251 mcview_move_right (mcview_t * view, off_t columns)
 252 {
 253     if (view->hex_mode)
 254     {
 255         off_t last_byte;
 256         off_t old_cursor = view->hex_cursor;
 257         last_byte = mcview_offset_doz (mcview_get_filesize (view), 1);
 258         assert (columns == 1);
 259         if (view->hexview_in_text || view->hexedit_lownibble)
 260         {
 261             if (view->hex_cursor < last_byte)
 262                 view->hex_cursor++;
 263         }
 264         if (!view->hexview_in_text)
 265             if (old_cursor < last_byte || !view->hexedit_lownibble)
 266                 view->hexedit_lownibble = !view->hexedit_lownibble;
 267     }
 268     else
 269     {
 270         view->dpy_text_column += columns;
 271     }
 272     mcview_movement_fixups (view, FALSE);
 273 }
 274
 275 /* --------------------------------------------------------------------------------------------- */
 276
 277 void
 278 mcview_scroll_to_cursor (mcview_t * view)
 279 {
 280     if (view->hex_mode)
 281     {
 282         const off_t bytes = view->bytes_per_line;
 283         const off_t displaysize = view->data_area.height * bytes;
 284         const off_t cursor = view->hex_cursor;
 285         off_t topleft = view->dpy_start;
 286
 287         if (topleft + displaysize <= cursor)
 288             topleft = mcview_offset_rounddown (cursor, bytes) - (displaysize - bytes);
 289         if (cursor < topleft)
 290             topleft = mcview_offset_rounddown (cursor, bytes);
 291         view->dpy_start = topleft;
 292     }
 293 }
 294
 295 /* --------------------------------------------------------------------------------------------- */
 296
 297 void
 298 mcview_moveto_top (mcview_t * view)
 299 {
 300     view->dpy_start = 0;
 301     view->hex_cursor = 0;
 302     view->dpy_text_column = 0;
 303     mcview_movement_fixups (view, TRUE);
 304 }
 305
 306 /* --------------------------------------------------------------------------------------------- */
 307
 308 void
 309 mcview_moveto_bottom (mcview_t * view)
 310 {
 311     off_t filesize;
 312
 313     mcview_update_filesize (view);
 314
 315     if (view->growbuf_in_use)
 316         mcview_growbuf_read_until (view, OFFSETTYPE_MAX);
 317
 318     filesize = mcview_get_filesize (view);
 319
 320     if (view->hex_mode)
 321     {
 322         view->hex_cursor = mcview_offset_doz (filesize, 1);
 323         mcview_movement_fixups (view, TRUE);
 324     }
 325     else
 326     {
 327         const off_t datalines = view->data_area.height;
 328
 329         view->dpy_start = filesize;
 330         mcview_move_up (view, datalines);
 331     }
 332 }
 333
 334 /* --------------------------------------------------------------------------------------------- */
 335
 336 void
 337 mcview_moveto_bol (mcview_t * view)
 338 {
 339     if (view->hex_mode)
 340     {
 341         view->hex_cursor -= view->hex_cursor % view->bytes_per_line;
 342     }
 343     else if (!view->text_wrap_mode)
 344     {
 345         view->dpy_start = mcview_bol (view, view->dpy_start, 0);
 346     }
 347     view->dpy_text_column = 0;
 348     mcview_movement_fixups (view, TRUE);
 349 }
 350
 351 /* --------------------------------------------------------------------------------------------- */
 352
 353 void
 354 mcview_moveto_eol (mcview_t * view)
 355 {
 356     off_t bol;
 357     if (view->hex_mode)
 358     {
 359         off_t filesize;
 360
 361         bol = mcview_offset_rounddown (view->hex_cursor, view->bytes_per_line);
 362         if (mcview_get_byte_indexed (view, bol, view->bytes_per_line - 1, NULL) == TRUE)
 363         {
 364             view->hex_cursor = bol + view->bytes_per_line - 1;
 365         }
 366         else
 367         {
 368             filesize = mcview_get_filesize (view);
 369             view->hex_cursor = mcview_offset_doz (filesize, 1);
 370         }
 371     }
 372     else
 373     {
 374         off_t eol;
 375         bol = mcview_bol (view, view->dpy_start, 0);
 376         eol = mcview_eol (view, view->dpy_start, mcview_get_filesize (view));
 377         if (!view->utf8)
 378         {
 379             if (eol > bol)
 380                 view->dpy_text_column = eol - bol;
 381         }
 382         else
 383         {
 384             char *str = NULL;
 385             switch (view->datasource)
 386             {
 387             case DS_STDIO_PIPE:
 388             case DS_VFS_PIPE:
 389                 str = mcview_get_ptr_growing_buffer (view, bol);
 390                 break;
 391             case DS_FILE:
 392                 str = mcview_get_ptr_file (view, bol);
 393                 break;
 394             case DS_STRING:
 395                 str = mcview_get_ptr_string (view, bol);
 396                 break;
 397             case DS_NONE:
 398                 break;
 399             }
 400             if (str != NULL && eol > bol)
 401                 view->dpy_text_column = g_utf8_strlen (str, eol - bol);
 402             else
 403                 view->dpy_text_column = eol - bol;
 404         }
 405         view->dpy_text_column = max (0, view->dpy_text_column - view->data_area.width);
 406     }
 407     mcview_movement_fixups (view, FALSE);
 408 }
 409
 410 /* --------------------------------------------------------------------------------------------- */
 411
 412 void
 413 mcview_moveto_offset (mcview_t * view, off_t offset)
 414 {
 415     if (view->hex_mode)
 416     {
 417         view->hex_cursor = offset;
 418         view->dpy_start = offset - offset % view->bytes_per_line;
 419     }
 420     else
 421     {
 422         view->dpy_start = offset;
 423     }
 424     mcview_movement_fixups (view, TRUE);
 425 }
 426
 427 /* --------------------------------------------------------------------------------------------- */
 428
 429 void
 430 mcview_moveto (mcview_t * view, off_t line, off_t col)
 431 {
 432     off_t offset;
 433
 434     mcview_coord_to_offset (view, &offset, line, col);
 435     mcview_moveto_offset (view, offset);
 436 }
 437
 438 /* --------------------------------------------------------------------------------------------- */
 439
 440 void
 441 mcview_coord_to_offset (mcview_t * view, off_t * ret_offset, off_t line, off_t column)
 442 {
 443     coord_cache_entry_t coord;
 444
 445     coord.cc_line = line;
 446     coord.cc_column = column;
 447     coord.cc_nroff_column = column;
 448     mcview_ccache_lookup (view, &coord, CCACHE_OFFSET);
 449     *ret_offset = coord.cc_offset;
 450 }
 451
 452 /* --------------------------------------------------------------------------------------------- */
 453
 454 void
 455 mcview_offset_to_coord (mcview_t * view, off_t * ret_line, off_t * ret_column, off_t offset)
 456 {
 457     coord_cache_entry_t coord;
 458
 459     coord.cc_offset = offset;
 460     mcview_ccache_lookup (view, &coord, CCACHE_LINECOL);
 461
 462     *ret_line = coord.cc_line;
 463     *ret_column = (view->text_nroff_mode) ? coord.cc_nroff_column : coord.cc_column;
 464 }
 465
 466 /* --------------------------------------------------------------------------------------------- */
 467
 468 void
 469 mcview_place_cursor (mcview_t * view)
 470 {
 471     const screen_dimen top = view->data_area.top;
 472     const screen_dimen left = view->data_area.left;
 473     screen_dimen col = view->cursor_col;
 474     if (!view->hexview_in_text && view->hexedit_lownibble)
 475         col++;
 476     widget_move (&view->widget, top + view->cursor_row, left + col);
 477 }
 478
 479 /* --------------------------------------------------------------------------------------------- */
 480 /** we have set view->search_start and view->search_end and must set
 481  * view->dpy_text_column and view->dpy_start
 482  * try to display maximum of match */
 483
 484 void
 485 mcview_moveto_match (mcview_t * view)
 486 {
 487     off_t offset;
 488
 489     offset = view->search_start;
 490
 491     if (view->hex_mode)
 492     {
 493         view->hex_cursor = offset;
 494         view->dpy_start = offset - offset % view->bytes_per_line;
 495     }
 496     else
 497     {
 498         view->dpy_start = mcview_bol (view, offset, 0);
 499     }
 500
 501     mcview_scroll_to_cursor (view);
 502     view->dirty++;
 503 }
 504
 505 /* --------------------------------------------------------------------------------------------- */