src/viewer/hex.c

   1 /*
   2    Internal file viewer for the Midnight Commander
   3    Function for hex view
   4
   5    Copyright (C) 1994-2014
   6    Free Software Foundation, Inc.
   7
   8    Written by:
   9    Miguel de Icaza, 1994, 1995, 1998
  10    Janne Kukonlehto, 1994, 1995
  11    Jakub Jelinek, 1995
  12    Joseph M. Hinkle, 1996
  13    Norbert Warmuth, 1997
  14    Pavel Machek, 1998
  15    Roland Illig <roland.illig@gmx.de>, 2004, 2005
  16    Slava Zanko <slavazanko@google.com>, 2009, 2013
  17    Andrew Borodin <aborodin@vmail.ru>, 2009
  18    Ilia Maslakov <il.smind@gmail.com>, 2009
  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 3 of the License,
  25    or (at your option) any later version.
  26
  27    The Midnight Commander is distributed in the hope that it will be useful,
  28    but WITHOUT ANY WARRANTY; without even the implied warranty of
  29    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30    GNU 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, see <http://www.gnu.org/licenses/>.
  34  */
  35
  36 #include <config.h>
  37
  38 #include <errno.h>
  39 #include <fcntl.h>
  40 #include <inttypes.h>           /* uintmax_t */
  41
  42 #include "lib/global.h"
  43 #include "lib/tty/tty.h"
  44 #include "lib/skin.h"
  45 #include "lib/vfs/vfs.h"
  46 #include "lib/lock.h"           /* lock_file() and unlock_file() */
  47 #include "lib/util.h"
  48 #include "lib/widget.h"
  49 #ifdef HAVE_CHARSET
  50 #include "lib/charsets.h"
  51 #endif
  52
  53 #include "internal.h"
  54
  55 /*** global variables ****************************************************************************/
  56
  57 /*** file scope macro definitions ****************************************************************/
  58
  59 /*** file scope type declarations ****************************************************************/
  60
  61 typedef enum
  62 {
  63     MARK_NORMAL,
  64     MARK_SELECTED,
  65     MARK_CURSOR,
  66     MARK_CHANGED
  67 } mark_t;
  68
  69 /*** file scope variables ************************************************************************/
  70
  71 static const char hex_char[] = "0123456789ABCDEF";
  72
  73 /*** file scope functions ************************************************************************/
  74 /* --------------------------------------------------------------------------------------------- */
  75
  76 #ifdef HAVE_CHARSET
  77 static int
  78 utf8_to_int (char *str, int *char_width, gboolean * result)
  79 {
  80     int res = -1;
  81     gunichar ch;
  82     gchar *next_ch = NULL;
  83     int width = 0;
  84
  85     *result = TRUE;
  86
  87     if (str == NULL)
  88     {
  89         *result = FALSE;
  90         return 0;
  91     }
  92
  93     res = g_utf8_get_char_validated (str, -1);
  94
  95     if (res < 0)
  96         ch = *str;
  97     else
  98     {
  99         ch = res;
 100         /* Calculate UTF-8 char width */
 101         next_ch = g_utf8_next_char (str);
 102         if (next_ch)
 103             width = next_ch - str;
 104         else
 105             ch = 0;
 106     }
 107     *char_width = width;
 108     return ch;
 109 }
 110 #endif /* HAVE_CHARSET */
 111
 112 /* --------------------------------------------------------------------------------------------- */
 113 /** Determine the state of the current byte.
 114  *
 115  * @param view viewer object
 116  * @param from offset
 117  * @param curr current node
 118  */
 119
 120 static mark_t
 121 mcview_hex_calculate_boldflag (mcview_t * view, off_t from, struct hexedit_change_node *curr)
 122 {
 123     return (from == view->hex_cursor) ? MARK_CURSOR
 124         : (curr != NULL && from == curr->offset) ? MARK_CHANGED
 125         : (view->search_start <= from && from < view->search_end) ? MARK_SELECTED : MARK_NORMAL;
 126 }
 127
 128 /* --------------------------------------------------------------------------------------------- */
 129 /*** public functions ****************************************************************************/
 130 /* --------------------------------------------------------------------------------------------- */
 131
 132 void
 133 mcview_display_hex (mcview_t * view)
 134 {
 135     const screen_dimen top = view->data_area.top;
 136     const screen_dimen left = view->data_area.left;
 137     const screen_dimen height = view->data_area.height;
 138     const screen_dimen width = view->data_area.width;
 139     const int ngroups = view->bytes_per_line / 4;
 140     const screen_dimen text_start = 8 + 13 * ngroups + ((width < 80) ? 0 : (ngroups - 1 + 1));
 141     /* 8 characters are used for the file offset, and every hex group
 142      * takes 13 characters. On "big" screens, the groups are separated
 143      * by an extra vertical line, and there is an extra space before the
 144      * text column.
 145      */
 146
 147     screen_dimen row;
 148     off_t from;
 149     int c;
 150     mark_t boldflag = MARK_NORMAL;
 151     struct hexedit_change_node *curr = view->change_list;
 152 #ifdef HAVE_CHARSET
 153     int ch = 0;
 154 #endif /* HAVE_CHARSET */
 155
 156     char hex_buff[10];          /* A temporary buffer for sprintf and mvwaddstr */
 157     int bytes;                  /* Number of bytes already printed on the line */
 158
 159     mcview_display_clean (view);
 160
 161     /* Find the first displayable changed byte */
 162     from = view->dpy_start;
 163     while (curr && (curr->offset < from))
 164     {
 165         curr = curr->next;
 166     }
 167
 168     for (row = 0; mcview_get_byte (view, from, NULL) == TRUE && row < height; row++)
 169     {
 170         screen_dimen col = 0;
 171         size_t i;
 172
 173         col = 0;
 174
 175         /* Print the hex offset */
 176         g_snprintf (hex_buff, sizeof (hex_buff), "%08" PRIXMAX " ", (uintmax_t) from);
 177         widget_move (view, top + row, left);
 178         tty_setcolor (VIEW_BOLD_COLOR);
 179         for (i = 0; col < width && hex_buff[i] != '\0'; i++)
 180         {
 181             tty_print_char (hex_buff[i]);
 182             /*              tty_print_char(hex_buff[i]); */
 183             col += 1;
 184         }
 185         tty_setcolor (VIEW_NORMAL_COLOR);
 186
 187         for (bytes = 0; bytes < view->bytes_per_line; bytes++, from++)
 188         {
 189
 190 #ifdef HAVE_CHARSET
 191             if (view->utf8)
 192             {
 193                 int cw = 1;
 194                 gboolean read_res = TRUE;
 195
 196                 ch = mcview_get_utf (view, from, &cw, &read_res);
 197                 if (!read_res)
 198                     break;
 199                 /* char width is greater 0 bytes */
 200                 if (cw != 0)
 201                 {
 202                     int cnt;
 203                     char corr_buf[UTF8_CHAR_LEN + 1];
 204                     struct hexedit_change_node *corr = curr;
 205                     int res;
 206
 207                     res = g_unichar_to_utf8 (ch, (char *) corr_buf);
 208
 209                     for (cnt = 0; cnt < cw; cnt++)
 210                     {
 211                         if (curr != NULL && from + cnt == curr->offset)
 212                         {
 213                             /* replace only changed bytes in array of multibyte char */
 214                             corr_buf[cnt] = curr->value;
 215                             curr = curr->next;
 216                         }
 217                     }
 218                     corr_buf[res] = '\0';
 219                     /* Determine the state of the current multibyte char */
 220                     ch = utf8_to_int ((char *) corr_buf, &cw, &read_res);
 221                     curr = corr;
 222                 }
 223             }
 224 #endif /* HAVE_CHARSET */
 225             if (!mcview_get_byte (view, from, &c))
 226                 break;
 227
 228             /* Save the cursor position for mcview_place_cursor() */
 229             if (from == view->hex_cursor && !view->hexview_in_text)
 230             {
 231                 view->cursor_row = row;
 232                 view->cursor_col = col;
 233             }
 234
 235             /* Determine the state of the current byte */
 236             boldflag = mcview_hex_calculate_boldflag (view, from, curr);
 237
 238             /* Determine the value of the current byte */
 239             if (curr != NULL && from == curr->offset)
 240             {
 241                 c = curr->value;
 242                 curr = curr->next;
 243             }
 244
 245             /* Select the color for the hex number */
 246             tty_setcolor (boldflag == MARK_NORMAL ? VIEW_NORMAL_COLOR :
 247                           boldflag == MARK_SELECTED ? VIEW_BOLD_COLOR :
 248                           boldflag == MARK_CHANGED ? VIEW_UNDERLINED_COLOR :
 249                           /* boldflag == MARK_CURSOR */
 250                           view->hexview_in_text ? VIEW_SELECTED_COLOR : VIEW_UNDERLINED_COLOR);
 251
 252             /* Print the hex number */
 253             widget_move (view, top + row, left + col);
 254             if (col < width)
 255             {
 256                 tty_print_char (hex_char[c / 16]);
 257                 col += 1;
 258             }
 259             if (col < width)
 260             {
 261                 tty_print_char (hex_char[c % 16]);
 262                 col += 1;
 263             }
 264
 265             /* Print the separator */
 266             tty_setcolor (VIEW_NORMAL_COLOR);
 267             if (bytes != view->bytes_per_line - 1)
 268             {
 269                 if (col < width)
 270                 {
 271                     tty_print_char (' ');
 272                     col += 1;
 273                 }
 274
 275                 /* After every four bytes, print a group separator */
 276                 if (bytes % 4 == 3)
 277                 {
 278                     if (view->data_area.width >= 80 && col < width)
 279                     {
 280                         tty_print_one_vline (TRUE);
 281                         col += 1;
 282                     }
 283                     if (col < width)
 284                     {
 285                         tty_print_char (' ');
 286                         col += 1;
 287                     }
 288                 }
 289             }
 290
 291             /* Select the color for the character; this differs from the
 292              * hex color when boldflag == MARK_CURSOR */
 293             tty_setcolor (boldflag == MARK_NORMAL ? VIEW_NORMAL_COLOR :
 294                           boldflag == MARK_SELECTED ? VIEW_BOLD_COLOR :
 295                           boldflag == MARK_CHANGED ? VIEW_UNDERLINED_COLOR :
 296                           /* boldflag == MARK_CURSOR */
 297                           view->hexview_in_text ? VIEW_SELECTED_COLOR : MARKED_SELECTED_COLOR);
 298
 299
 300 #ifdef HAVE_CHARSET
 301             if (mc_global.utf8_display)
 302             {
 303                 if (!view->utf8)
 304                 {
 305                     c = convert_from_8bit_to_utf_c ((unsigned char) c, view->converter);
 306                 }
 307                 if (!g_unichar_isprint (c))
 308                     c = '.';
 309             }
 310             else if (view->utf8)
 311                 ch = convert_from_utf_to_current_c (ch, view->converter);
 312             else
 313 #endif
 314             {
 315 #ifdef HAVE_CHARSET
 316                 c = convert_to_display_c (c);
 317 #endif
 318
 319                 if (!is_printable (c))
 320                     c = '.';
 321             }
 322
 323             /* Print corresponding character on the text side */
 324             if (text_start + bytes < width)
 325             {
 326                 widget_move (view, top + row, left + text_start + bytes);
 327 #ifdef HAVE_CHARSET
 328                 if (view->utf8)
 329                     tty_print_anychar (ch);
 330                 else
 331 #endif
 332                     tty_print_char (c);
 333             }
 334
 335             /* Save the cursor position for mcview_place_cursor() */
 336             if (from == view->hex_cursor && view->hexview_in_text)
 337             {
 338                 view->cursor_row = row;
 339                 view->cursor_col = text_start + bytes;
 340             }
 341         }
 342     }
 343
 344     /* Be polite to the other functions */
 345     tty_setcolor (VIEW_NORMAL_COLOR);
 346
 347     mcview_place_cursor (view);
 348     view->dpy_end = from;
 349 }
 350
 351 /* --------------------------------------------------------------------------------------------- */
 352
 353 gboolean
 354 mcview_hexedit_save_changes (mcview_t * view)
 355 {
 356     int answer = 0;
 357
 358     if (view->change_list == NULL)
 359         return TRUE;
 360
 361     while (answer == 0)
 362     {
 363         int fp;
 364         char *text;
 365         struct hexedit_change_node *curr, *next;
 366
 367 #ifdef HAVE_ASSERT_H
 368         assert (view->filename_vpath != NULL);
 369 #endif
 370
 371         fp = mc_open (view->filename_vpath, O_WRONLY);
 372         if (fp != -1)
 373         {
 374             for (curr = view->change_list; curr != NULL; curr = next)
 375             {
 376                 next = curr->next;
 377
 378                 if (mc_lseek (fp, curr->offset, SEEK_SET) == -1
 379                     || mc_write (fp, &(curr->value), 1) != 1)
 380                     goto save_error;
 381
 382                 /* delete the saved item from the change list */
 383                 view->change_list = next;
 384                 view->dirty++;
 385                 mcview_set_byte (view, curr->offset, curr->value);
 386                 g_free (curr);
 387             }
 388
 389             view->change_list = NULL;
 390
 391             if (view->locked)
 392                 view->locked = unlock_file (view->filename_vpath);
 393
 394             if (mc_close (fp) == -1)
 395                 message (D_ERROR, _("Save file"),
 396                          _("Error while closing the file:\n%s\n"
 397                            "Data may have been written or not"), unix_error_string (errno));
 398
 399             view->dirty++;
 400             return TRUE;
 401         }
 402
 403       save_error:
 404         text = g_strdup_printf (_("Cannot save file:\n%s"), unix_error_string (errno));
 405         (void) mc_close (fp);
 406
 407         answer = query_dialog (_("Save file"), text, D_ERROR, 2, _("&Retry"), _("&Cancel"));
 408         g_free (text);
 409     }
 410
 411     return FALSE;
 412 }
 413
 414 /* --------------------------------------------------------------------------------------------- */
 415
 416 void
 417 mcview_toggle_hexedit_mode (mcview_t * view)
 418 {
 419     view->hexedit_mode = !view->hexedit_mode;
 420     view->dpy_bbar_dirty = TRUE;
 421     view->dirty++;
 422 }
 423
 424 /* --------------------------------------------------------------------------------------------- */
 425
 426 void
 427 mcview_hexedit_free_change_list (mcview_t * view)
 428 {
 429     struct hexedit_change_node *curr, *next;
 430
 431     for (curr = view->change_list; curr != NULL; curr = next)
 432     {
 433         next = curr->next;
 434         g_free (curr);
 435     }
 436     view->change_list = NULL;
 437
 438     if (view->locked)
 439         view->locked = unlock_file (view->filename_vpath);
 440
 441     view->dirty++;
 442 }
 443
 444 /* --------------------------------------------------------------------------------------------- */
 445
 446 void
 447 mcview_enqueue_change (struct hexedit_change_node **head, struct hexedit_change_node *node)
 448 {
 449     /* chnode always either points to the head of the list or
 450      * to one of the ->next fields in the list. The value at
 451      * this location will be overwritten with the new node.   */
 452     struct hexedit_change_node **chnode = head;
 453
 454     while (*chnode != NULL && (*chnode)->offset < node->offset)
 455         chnode = &((*chnode)->next);
 456
 457     node->next = *chnode;
 458     *chnode = node;
 459 }
 460
 461 /* --------------------------------------------------------------------------------------------- */