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 static void
  71 mcview_movement_fixups (mcview_t * view, gboolean reset_search)
  72 {
  73     mcview_scroll_to_cursor (view);
  74     if (reset_search)
  75     {
  76         view->search_start = view->dpy_start;
  77         view->search_end = view->dpy_start;
  78     }
  79     view->dirty++;
  80 }
  81
  82 /* --------------------------------------------------------------------------------------------- */
  83
  84 /*** public functions ****************************************************************************/
  85
  86 /* --------------------------------------------------------------------------------------------- */
  87
  88 void
  89 mcview_move_up (mcview_t * view, off_t lines)
  90 {
  91     off_t new_offset;
  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         for (i = 0; i < lines; i++)
 110         {
 111             new_offset = mcview_bol (view, view->dpy_start);
 112             if (new_offset > 0)
 113                 new_offset--;
 114             new_offset = mcview_bol (view, new_offset);
 115             if (new_offset < 0)
 116                 new_offset = 0;
 117             view->dpy_start = new_offset;
 118         }
 119     }
 120     mcview_movement_fixups (view, TRUE);
 121 }
 122
 123 /* --------------------------------------------------------------------------------------------- */
 124
 125 void
 126 mcview_move_down (mcview_t * view, off_t lines)
 127 {
 128     off_t last_byte;
 129     last_byte = mcview_get_filesize (view);
 130     if (view->hex_mode)
 131     {
 132         off_t i, limit;
 133
 134         if (last_byte >= (off_t) view->bytes_per_line)
 135             limit = last_byte - view->bytes_per_line;
 136         else
 137             limit = 0;
 138         for (i = 0; i < lines && view->hex_cursor < limit; i++)
 139         {
 140             view->hex_cursor += view->bytes_per_line;
 141             if (lines != 1)
 142                 view->dpy_start += view->bytes_per_line;
 143         }
 144     }
 145     else
 146     {
 147         off_t i;
 148         for (i = 0; i < lines; i++)
 149         {
 150             off_t new_offset;
 151             new_offset = mcview_eol (view, view->dpy_start);
 152             view->dpy_start = new_offset;
 153         }
 154     }
 155     mcview_movement_fixups (view, TRUE);
 156 }
 157
 158 /* --------------------------------------------------------------------------------------------- */
 159
 160 void
 161 mcview_move_left (mcview_t * view, off_t columns)
 162 {
 163     if (view->hex_mode)
 164     {
 165         off_t old_cursor = view->hex_cursor;
 166         assert (columns == 1);
 167         if (view->hexview_in_text || !view->hexedit_lownibble)
 168         {
 169             if (view->hex_cursor > 0)
 170                 view->hex_cursor--;
 171         }
 172         if (!view->hexview_in_text)
 173             if (old_cursor > 0 || view->hexedit_lownibble)
 174                 view->hexedit_lownibble = !view->hexedit_lownibble;
 175     }
 176     else if (view->text_wrap_mode)
 177     {
 178         /* nothing to do */
 179     }
 180     else
 181     {
 182         if (view->dpy_text_column >= columns)
 183             view->dpy_text_column -= columns;
 184         else
 185             view->dpy_text_column = 0;
 186     }
 187     mcview_movement_fixups (view, FALSE);
 188 }
 189
 190 /* --------------------------------------------------------------------------------------------- */
 191
 192 void
 193 mcview_move_right (mcview_t * view, off_t columns)
 194 {
 195     if (view->hex_mode)
 196     {
 197         off_t last_byte;
 198         off_t old_cursor = view->hex_cursor;
 199         last_byte = mcview_offset_doz (mcview_get_filesize (view), 1);
 200         assert (columns == 1);
 201         if (view->hexview_in_text || view->hexedit_lownibble)
 202         {
 203             if (view->hex_cursor < last_byte)
 204                 view->hex_cursor++;
 205         }
 206         if (!view->hexview_in_text)
 207             if (old_cursor < last_byte || !view->hexedit_lownibble)
 208                 view->hexedit_lownibble = !view->hexedit_lownibble;
 209     }
 210     else if (view->text_wrap_mode)
 211     {
 212         /* nothing to do */
 213     }
 214     else
 215     {
 216         view->dpy_text_column += columns;
 217     }
 218     mcview_movement_fixups (view, FALSE);
 219 }
 220
 221 /* --------------------------------------------------------------------------------------------- */
 222
 223 void
 224 mcview_scroll_to_cursor (mcview_t * view)
 225 {
 226     if (view->hex_mode)
 227     {
 228         const off_t bytes = view->bytes_per_line;
 229         const off_t displaysize = view->data_area.height * bytes;
 230         const off_t cursor = view->hex_cursor;
 231         off_t topleft = view->dpy_start;
 232
 233         if (topleft + displaysize <= cursor)
 234             topleft = mcview_offset_rounddown (cursor, bytes) - (displaysize - bytes);
 235         if (cursor < topleft)
 236             topleft = mcview_offset_rounddown (cursor, bytes);
 237         view->dpy_start = topleft;
 238     }
 239 }
 240
 241 /* --------------------------------------------------------------------------------------------- */
 242
 243 void
 244 mcview_moveto_top (mcview_t * view)
 245 {
 246     view->dpy_start = 0;
 247     view->hex_cursor = 0;
 248     view->dpy_text_column = 0;
 249     mcview_movement_fixups (view, TRUE);
 250 }
 251
 252 /* --------------------------------------------------------------------------------------------- */
 253
 254 void
 255 mcview_moveto_bottom (mcview_t * view)
 256 {
 257     off_t datalines, lines_up, filesize, last_offset;
 258
 259     mcview_update_filesize (view);
 260
 261     if (view->growbuf_in_use)
 262         mcview_growbuf_read_until (view, OFFSETTYPE_MAX);
 263
 264     filesize = mcview_get_filesize (view);
 265     datalines = view->data_area.height;
 266     lines_up = mcview_offset_doz (datalines, 1);
 267
 268     if (view->hex_mode)
 269     {
 270         last_offset = mcview_offset_doz (filesize, 1);
 271         view->hex_cursor = filesize;
 272         mcview_move_up (view, lines_up);
 273         view->hex_cursor = last_offset;
 274     }
 275     else
 276     {
 277         view->dpy_start = filesize;
 278         mcview_move_up (view, 1);
 279     }
 280 }
 281
 282 /* --------------------------------------------------------------------------------------------- */
 283
 284 void
 285 mcview_moveto_bol (mcview_t * view)
 286 {
 287     if (view->hex_mode)
 288     {
 289         view->hex_cursor -= view->hex_cursor % view->bytes_per_line;
 290     }
 291     else if (!view->text_wrap_mode)
 292     {
 293         view->dpy_start = mcview_bol (view, view->dpy_start);
 294     }
 295     mcview_movement_fixups (view, TRUE);
 296 }
 297
 298 /* --------------------------------------------------------------------------------------------- */
 299
 300 void
 301 mcview_moveto_eol (mcview_t * view)
 302 {
 303     if (view->hex_mode)
 304     {
 305         off_t filesize, bol;
 306
 307         bol = mcview_offset_rounddown (view->hex_cursor, view->bytes_per_line);
 308         if (mcview_get_byte_indexed (view, bol, view->bytes_per_line - 1, NULL) == TRUE)
 309         {
 310             view->hex_cursor = bol + view->bytes_per_line - 1;
 311         }
 312         else
 313         {
 314             filesize = mcview_get_filesize (view);
 315             view->hex_cursor = mcview_offset_doz (filesize, 1);
 316         }
 317     }
 318     mcview_movement_fixups (view, FALSE);
 319 }
 320
 321 /* --------------------------------------------------------------------------------------------- */
 322
 323 void
 324 mcview_moveto_offset (mcview_t * view, off_t offset)
 325 {
 326     if (view->hex_mode)
 327     {
 328         view->hex_cursor = offset;
 329         view->dpy_start = offset - offset % view->bytes_per_line;
 330     }
 331     else
 332     {
 333         view->dpy_start = offset;
 334     }
 335     mcview_movement_fixups (view, TRUE);
 336 }
 337
 338 /* --------------------------------------------------------------------------------------------- */
 339
 340 void
 341 mcview_moveto (mcview_t * view, off_t line, off_t col)
 342 {
 343     off_t offset;
 344
 345     mcview_coord_to_offset (view, &offset, line, col);
 346     mcview_moveto_offset (view, offset);
 347 }
 348
 349 /* --------------------------------------------------------------------------------------------- */
 350
 351 void
 352 mcview_coord_to_offset (mcview_t * view, off_t * ret_offset, off_t line, off_t column)
 353 {
 354     coord_cache_entry_t coord;
 355
 356     coord.cc_line = line;
 357     coord.cc_column = column;
 358     coord.cc_nroff_column = column;
 359     mcview_ccache_lookup (view, &coord, CCACHE_OFFSET);
 360     *ret_offset = coord.cc_offset;
 361 }
 362
 363 /* --------------------------------------------------------------------------------------------- */
 364
 365 void
 366 mcview_offset_to_coord (mcview_t * view, off_t * ret_line, off_t * ret_column, off_t offset)
 367 {
 368     coord_cache_entry_t coord;
 369
 370     coord.cc_offset = offset;
 371     mcview_ccache_lookup (view, &coord, CCACHE_LINECOL);
 372
 373     *ret_line = coord.cc_line;
 374     *ret_column = (view->text_nroff_mode) ? coord.cc_nroff_column : coord.cc_column;
 375 }
 376
 377 /* --------------------------------------------------------------------------------------------- */
 378
 379 void
 380 mcview_place_cursor (mcview_t * view)
 381 {
 382     const screen_dimen top = view->data_area.top;
 383     const screen_dimen left = view->data_area.left;
 384     screen_dimen col = view->cursor_col;
 385     if (!view->hexview_in_text && view->hexedit_lownibble)
 386         col++;
 387     widget_move (&view->widget, top + view->cursor_row, left + col);
 388 }
 389
 390 /* --------------------------------------------------------------------------------------------- */
 391
 392 /* we have set view->search_start and view->search_end and must set
 393  * view->dpy_text_column and view->dpy_start
 394  * try to display maximum of match */
 395 void
 396 mcview_moveto_match (mcview_t * view)
 397 {
 398     off_t offset;
 399
 400     offset = view->search_start;
 401
 402     if (view->hex_mode)
 403     {
 404         view->hex_cursor = offset;
 405         view->dpy_start = offset - offset % view->bytes_per_line;
 406     }
 407     else
 408     {
 409         view->dpy_start = mcview_bol (view, offset);
 410     }
 411
 412     mcview_scroll_to_cursor (view);
 413     view->dirty++;
 414 }
 415
 416 /* --------------------------------------------------------------------------------------------- */