src/editor/editdraw.c

   1 /*
   2    Editor text drawing.
   3
   4    Copyright (C) 1996, 1997, 1998, 2001, 2002, 2003, 2004, 2005, 2006,
   5    2007, 2011, 2012
   6    The Free Software Foundation, Inc.
   7
   8    Written by:
   9    Paul Sheer, 1996, 1997
  10    Andrew Borodin <aborodin@vmail.ru> 2012
  11
  12    This file is part of the Midnight Commander.
  13
  14    The Midnight Commander is free software: you can redistribute it
  15    and/or modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation, either version 3 of the License,
  17    or (at your option) any later version.
  18
  19    The Midnight Commander is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26  */
  27
  28 /** \file
  29  *  \brief Source: editor text drawing
  30  *  \author Paul Sheer
  31  *  \date 1996, 1997
  32  */
  33
  34 #include <config.h>
  35 #include <stdlib.h>
  36 #include <stdio.h>
  37 #include <stdarg.h>
  38 #include <sys/types.h>
  39 #include <unistd.h>
  40 #include <string.h>
  41 #include <ctype.h>
  42 #include <errno.h>
  43 #include <sys/stat.h>
  44
  45 #include "lib/global.h"
  46 #include "lib/tty/tty.h"        /* tty_printf() */
  47 #include "lib/tty/key.h"        /* is_idle() */
  48 #include "lib/skin.h"
  49 #include "lib/strutil.h"        /* utf string functions */
  50 #include "lib/util.h"           /* is_printable() */
  51 #include "lib/widget.h"
  52 #ifdef HAVE_CHARSET
  53 #include "lib/charsets.h"
  54 #endif
  55
  56 #include "src/setup.h"          /* edit_tab_spacing */
  57
  58 #include "edit-impl.h"
  59 #include "editwidget.h"
  60
  61 /*** global variables ****************************************************************************/
  62
  63 /* Toggles statusbar draw style */
  64 int simple_statusbar = 0;
  65
  66 int visible_tabs = 1, visible_tws = 1;
  67
  68 /*** file scope macro definitions ****************************************************************/
  69
  70 #define MAX_LINE_LEN 1024
  71
  72 /* Text styles */
  73 #define MOD_ABNORMAL            (1 << 8)
  74 #define MOD_BOLD                (1 << 9)
  75 #define MOD_MARKED              (1 << 10)
  76 #define MOD_CURSOR              (1 << 11)
  77 #define MOD_WHITESPACE          (1 << 12)
  78
  79 #define edit_move(x,y) widget_move(edit, y, x);
  80
  81 #define key_pending(x) (!is_idle())
  82
  83 #define EDITOR_MINIMUM_TERMINAL_WIDTH 30
  84
  85 /*** file scope type declarations ****************************************************************/
  86
  87 struct line_s
  88 {
  89     unsigned int ch;
  90     unsigned int style;
  91 };
  92
  93 /*** file scope variables ************************************************************************/
  94
  95 /*** file scope functions ************************************************************************/
  96
  97 static inline void
  98 printwstr (const char *s, int len)
  99 {
 100     if (len > 0)
 101         tty_printf ("%-*.*s", len, len, s);
 102 }
 103
 104 /* --------------------------------------------------------------------------------------------- */
 105
 106 static inline void
 107 status_string (WEdit * edit, char *s, int w)
 108 {
 109     char byte_str[16];
 110
 111     /*
 112      * If we are at the end of file, print <EOF>,
 113      * otherwise print the current character as is (if printable),
 114      * as decimal and as hex.
 115      */
 116     if (edit->curs1 < edit->last_byte)
 117     {
 118 #ifdef HAVE_CHARSET
 119         if (edit->utf8)
 120         {
 121             unsigned int cur_utf = 0;
 122             int cw = 1;
 123
 124             cur_utf = edit_get_utf (edit, edit->curs1, &cw);
 125             if (cw > 0)
 126             {
 127                 g_snprintf (byte_str, sizeof (byte_str), "%04d 0x%03X",
 128                             (unsigned) cur_utf, (unsigned) cur_utf);
 129             }
 130             else
 131             {
 132                 cur_utf = edit_get_byte (edit, edit->curs1);
 133                 g_snprintf (byte_str, sizeof (byte_str), "%04d 0x%03X",
 134                             (int) cur_utf, (unsigned) cur_utf);
 135             }
 136         }
 137         else
 138 #endif
 139         {
 140             unsigned char cur_byte = 0;
 141
 142             cur_byte = edit_get_byte (edit, edit->curs1);
 143             g_snprintf (byte_str, sizeof (byte_str), "%4d 0x%03X",
 144                         (int) cur_byte, (unsigned) cur_byte);
 145         }
 146     }
 147     else
 148     {
 149         strcpy (byte_str, "<EOF>     ");
 150     }
 151
 152     /* The field lengths just prevent the status line from shortening too much */
 153     if (simple_statusbar)
 154         g_snprintf (s, w,
 155                     "%c%c%c%c %3ld %5ld/%ld %6ld/%ld %s %s",
 156                     edit->mark1 != edit->mark2 ? (edit->column_highlight ? 'C' : 'B') : '-',
 157                     edit->modified ? 'M' : '-',
 158                     macro_index < 0 ? '-' : 'R',
 159                     edit->overwrite == 0 ? '-' : 'O',
 160                     edit->curs_col + edit->over_col,
 161                     edit->curs_line + 1,
 162                     edit->total_lines + 1, (long) edit->curs1, (long) edit->last_byte, byte_str,
 163 #ifdef HAVE_CHARSET
 164                     mc_global.source_codepage >= 0 ? get_codepage_id (mc_global.source_codepage) :
 165 #endif
 166                     "");
 167     else
 168         g_snprintf (s, w,
 169                     "[%c%c%c%c] %2ld L:[%3ld+%2ld %3ld/%3ld] *(%-4ld/%4ldb) %s  %s",
 170                     edit->mark1 != edit->mark2 ? (edit->column_highlight ? 'C' : 'B') : '-',
 171                     edit->modified ? 'M' : '-',
 172                     macro_index < 0 ? '-' : 'R',
 173                     edit->overwrite == 0 ? '-' : 'O',
 174                     edit->curs_col + edit->over_col,
 175                     edit->start_line + 1,
 176                     edit->curs_row,
 177                     edit->curs_line + 1,
 178                     edit->total_lines + 1, (long) edit->curs1, (long) edit->last_byte, byte_str,
 179 #ifdef HAVE_CHARSET
 180                     mc_global.source_codepage >= 0 ? get_codepage_id (mc_global.source_codepage) :
 181 #endif
 182                     "");
 183 }
 184
 185 /* --------------------------------------------------------------------------------------------- */
 186 /**
 187  * Draw the status line at the top of the screen for fullscreen editor window.
 188  *
 189  * @param edit  editor object
 190  * @param color color pair
 191  */
 192
 193 static inline void
 194 edit_status_fullscreen (WEdit * edit, int color)
 195 {
 196     Widget *h = WIDGET (WIDGET (edit)->owner);
 197     const int w = h->cols;
 198     const size_t status_size = w + 1;
 199     char *const status = g_malloc (status_size);
 200     int status_len;
 201     const char *fname = "";
 202     int fname_len;
 203     const int gap = 3;          /* between the filename and the status */
 204     const int right_gap = 5;    /* at the right end of the screen */
 205     const int preferred_fname_len = 16;
 206
 207     status_string (edit, status, status_size);
 208     status_len = (int) str_term_width1 (status);
 209
 210     if (edit->filename_vpath != NULL)
 211         fname = x_basename (vfs_path_get_last_path_str (edit->filename_vpath));
 212
 213     fname_len = str_term_width1 (fname);
 214     if (fname_len < preferred_fname_len)
 215         fname_len = preferred_fname_len;
 216
 217     if (fname_len + gap + status_len + right_gap >= w)
 218     {
 219         if (preferred_fname_len + gap + status_len + right_gap >= w)
 220             fname_len = preferred_fname_len;
 221         else
 222             fname_len = w - (gap + status_len + right_gap);
 223         fname = str_trunc (fname, fname_len);
 224     }
 225
 226     widget_move (h, 0, 0);
 227     tty_setcolor (color);
 228     printwstr (fname, fname_len + gap);
 229     printwstr (status, w - (fname_len + gap));
 230
 231     if (simple_statusbar && w > EDITOR_MINIMUM_TERMINAL_WIDTH)
 232     {
 233         size_t percent = 100;
 234
 235         if (edit->total_lines + 1 != 0)
 236             percent = (edit->curs_line + 1) * 100 / (edit->total_lines + 1);
 237         widget_move (h, 0, w - 6 - 6);
 238         tty_printf (" %3d%%", percent);
 239     }
 240
 241     g_free (status);
 242 }
 243
 244 /* --------------------------------------------------------------------------------------------- */
 245 /**
 246  * Draw status line for editor window if window is not in fullscreen mode.
 247  *
 248  * @param edit editor object
 249  */
 250
 251 static inline void
 252 edit_status_window (WEdit * edit)
 253 {
 254     Widget *w = WIDGET (edit);
 255     int y, x;
 256     int cols = w->cols;
 257
 258     tty_setcolor (STATUSBAR_COLOR);
 259
 260     if (cols > 5)
 261     {
 262         const char *fname = N_("NoName");
 263         char *full_fname = NULL;
 264
 265         if (edit->filename_vpath != NULL)
 266         {
 267             full_fname = vfs_path_to_str (edit->filename_vpath);
 268             fname = x_basename (full_fname);
 269         }
 270 #ifdef ENABLE_NLS
 271         else
 272             fname = _(fname);
 273 #endif
 274
 275         edit_move (2, 0);
 276         tty_printf ("[%s]", str_term_trim (fname, w->cols - 8 - 6));
 277         g_free (full_fname);
 278     }
 279
 280     tty_getyx (&y, &x);
 281     x -= w->x;
 282     x += 4;
 283     if (x + 6 <= cols - 2 - 6)
 284     {
 285         edit_move (x, 0);
 286         tty_printf ("[%c%c%c%c]",
 287                     edit->mark1 != edit->mark2 ? (edit->column_highlight ? 'C' : 'B') : '-',
 288                     edit->modified ? 'M' : '-',
 289                     macro_index < 0 ? '-' : 'R', edit->overwrite == 0 ? '-' : 'O');
 290     }
 291
 292     if (cols > 30)
 293     {
 294         edit_move (2, w->lines - 1);
 295         tty_printf ("%3ld %5ld/%ld %6ld/%ld",
 296                     edit->curs_col + edit->over_col,
 297                     edit->curs_line + 1, edit->total_lines + 1, edit->curs1, edit->last_byte);
 298     }
 299
 300     /*
 301      * If we are at the end of file, print <EOF>,
 302      * otherwise print the current character as is (if printable),
 303      * as decimal and as hex.
 304      */
 305     if (cols > 46)
 306     {
 307         edit_move (32, w->lines - 1);
 308         if (edit->curs1 >= edit->last_byte)
 309             tty_print_string ("[<EOF>       ]");
 310 #ifdef HAVE_CHARSET
 311         else if (edit->utf8)
 312         {
 313             unsigned int cur_utf;
 314             int cw = 1;
 315
 316             cur_utf = edit_get_utf (edit, edit->curs1, &cw);
 317             if (cw <= 0)
 318                 cur_utf = edit_get_byte (edit, edit->curs1);
 319             tty_printf ("[%05d 0x%04X]", cur_utf, cur_utf);
 320         }
 321 #endif
 322         else
 323         {
 324             unsigned char cur_byte;
 325
 326             cur_byte = edit_get_byte (edit, edit->curs1);
 327             tty_printf ("[%05d 0x%04X]", (unsigned int) cur_byte, (unsigned int) cur_byte);
 328         }
 329     }
 330 }
 331
 332 /* --------------------------------------------------------------------------------------------- */
 333 /**
 334  * Draw a frame around edit area.
 335  *
 336  * @param edit   editor object
 337  * @param color  color pair
 338  * @param active TRUE if editor object is focused
 339  */
 340
 341 static inline void
 342 edit_draw_frame (const WEdit * edit, int color, gboolean active)
 343 {
 344     const Widget *w = (const Widget *) edit;
 345
 346     /* draw a frame around edit area */
 347     tty_setcolor (color);
 348     /* draw double frame for active window if skin supports that */
 349     tty_draw_box (w->y, w->x, w->lines, w->cols, !active);
 350     /* draw a drag marker */
 351     if (edit->drag_state == MCEDIT_DRAG_NORMAL)
 352     {
 353         tty_setcolor (EDITOR_FRAME_DRAG);
 354         widget_move (w, w->lines - 1, w->cols - 1);
 355         tty_print_alt_char (ACS_LRCORNER, TRUE);
 356     }
 357 }
 358
 359 /* --------------------------------------------------------------------------------------------- */
 360 /**
 361  * Draw a window control buttons.
 362  *
 363  * @param edit  editor object
 364  * @param color color pair
 365  */
 366
 367 static inline void
 368 edit_draw_window_icons (const WEdit * edit, int color)
 369 {
 370     const Widget *w = WIDGET (edit);
 371     char tmp[17];
 372
 373     tty_setcolor (color);
 374     if (edit->fullscreen)
 375         widget_move (w->owner, 0, WIDGET (w->owner)->cols - 6);
 376     else
 377         widget_move (w, 0, w->cols - 8);
 378     g_snprintf (tmp, sizeof (tmp), "[%s][%s]", edit_window_state_char, edit_window_close_char);
 379     tty_print_string (tmp);
 380 }
 381
 382 /* --------------------------------------------------------------------------------------------- */
 383
 384 static inline void
 385 print_to_widget (WEdit * edit, long row, int start_col, int start_col_real,
 386                  long end_col, struct line_s line[], char *status, int bookmarked)
 387 {
 388     Widget *w = WIDGET (edit);
 389
 390     struct line_s *p;
 391
 392     int x = start_col_real;
 393     int x1 = start_col + EDIT_TEXT_HORIZONTAL_OFFSET + option_line_state_width;
 394     int y = row + EDIT_TEXT_VERTICAL_OFFSET;
 395     int cols_to_skip = abs (x);
 396     int i;
 397     int wrap_start;
 398     int len;
 399
 400     if (!edit->fullscreen)
 401     {
 402         x1++;
 403         y++;
 404     }
 405
 406     tty_setcolor (EDITOR_NORMAL_COLOR);
 407     if (bookmarked != 0)
 408         tty_setcolor (bookmarked);
 409
 410     len = end_col + 1 - start_col;
 411     wrap_start = option_word_wrap_line_length + edit->start_col;
 412
 413     if (len > 0 && w->y + y >= 0)
 414     {
 415         if (!show_right_margin || wrap_start > end_col)
 416             tty_draw_hline (w->y + y, w->x + x1, ' ', len);
 417         else if (wrap_start < 0)
 418         {
 419             tty_setcolor (EDITOR_RIGHT_MARGIN_COLOR);
 420             tty_draw_hline (w->y + y, w->x + x1, ' ', len);
 421         }
 422         else
 423         {
 424             if (wrap_start > 0)
 425                 tty_draw_hline (w->y + y, w->x + x1, ' ', wrap_start);
 426
 427             len -= wrap_start;
 428             if (len > 0)
 429             {
 430                 tty_setcolor (EDITOR_RIGHT_MARGIN_COLOR);
 431                 tty_draw_hline (w->y + y, w->x + x1 + wrap_start, ' ', len);
 432             }
 433         }
 434     }
 435
 436     if (option_line_state)
 437     {
 438         tty_setcolor (LINE_STATE_COLOR);
 439         for (i = 0; i < LINE_STATE_WIDTH; i++)
 440         {
 441             edit_move (x1 + i - option_line_state_width, y);
 442             if (status[i] == '\0')
 443                 status[i] = ' ';
 444             tty_print_char (status[i]);
 445         }
 446     }
 447
 448     edit_move (x1, y);
 449     i = 1;
 450     for (p = line; p->ch != 0; p++)
 451     {
 452         int style;
 453         unsigned int textchar;
 454         int color;
 455
 456         if (cols_to_skip != 0)
 457         {
 458             cols_to_skip--;
 459             continue;
 460         }
 461
 462         style = p->style & 0xFF00;
 463         textchar = p->ch;
 464         color = p->style >> 16;
 465
 466         if (style & MOD_ABNORMAL)
 467         {
 468             /* Non-printable - use black background */
 469             color = 0;
 470         }
 471
 472         if (style & MOD_WHITESPACE)
 473         {
 474             if (style & MOD_MARKED)
 475             {
 476                 textchar = ' ';
 477                 tty_setcolor (EDITOR_MARKED_COLOR);
 478             }
 479             else
 480                 tty_setcolor (EDITOR_WHITESPACE_COLOR);
 481         }
 482         else if (style & MOD_BOLD)
 483             tty_setcolor (EDITOR_BOLD_COLOR);
 484         else if (style & MOD_MARKED)
 485             tty_setcolor (EDITOR_MARKED_COLOR);
 486         else
 487             tty_lowlevel_setcolor (color);
 488
 489         if (show_right_margin)
 490         {
 491             if (i > option_word_wrap_line_length + edit->start_col)
 492                 tty_setcolor (EDITOR_RIGHT_MARGIN_COLOR);
 493             i++;
 494         }
 495
 496         tty_print_anychar (textchar);
 497     }
 498 }
 499
 500 /* --------------------------------------------------------------------------------------------- */
 501 /** b is a pointer to the beginning of the line */
 502
 503 static void
 504 edit_draw_this_line (WEdit * edit, off_t b, long row, long start_col, long end_col)
 505 {
 506     Widget *w = WIDGET (edit);
 507
 508     struct line_s line[MAX_LINE_LEN];
 509     struct line_s *p = line;
 510
 511     off_t m1 = 0, m2 = 0, q;
 512     long c1, c2;
 513     int col, start_col_real;
 514     unsigned int c;
 515     int color;
 516     int abn_style;
 517     int i;
 518     unsigned int cur_line = 0;
 519     int book_mark = 0;
 520     char line_stat[LINE_STATE_WIDTH + 1] = "\0";
 521
 522     if (row > w->lines - 1 - EDIT_TEXT_VERTICAL_OFFSET - 2 * (edit->fullscreen ? 0 : 1))
 523         return;
 524
 525     if (book_mark_query_color (edit, edit->start_line + row, BOOK_MARK_COLOR))
 526         book_mark = BOOK_MARK_COLOR;
 527     else if (book_mark_query_color (edit, edit->start_line + row, BOOK_MARK_FOUND_COLOR))
 528         book_mark = BOOK_MARK_FOUND_COLOR;
 529
 530     if (book_mark)
 531         abn_style = book_mark << 16;
 532     else
 533         abn_style = MOD_ABNORMAL;
 534
 535     end_col -= EDIT_TEXT_HORIZONTAL_OFFSET + option_line_state_width;
 536     if (!edit->fullscreen)
 537     {
 538         end_col--;
 539         if (w->x + w->cols <= WIDGET (w->owner)->cols)
 540             end_col--;
 541     }
 542
 543     color = edit_get_syntax_color (edit, b - 1);
 544     q = edit_move_forward3 (edit, b, start_col - edit->start_col, 0);
 545     start_col_real = (col = (int) edit_move_forward3 (edit, b, 0, q)) + edit->start_col;
 546
 547     if (option_line_state)
 548     {
 549         cur_line = edit->start_line + row;
 550         if (cur_line <= (unsigned int) edit->total_lines)
 551         {
 552             g_snprintf (line_stat, LINE_STATE_WIDTH + 1, "%7i ", cur_line + 1);
 553         }
 554         else
 555         {
 556             memset (line_stat, ' ', LINE_STATE_WIDTH);
 557             line_stat[LINE_STATE_WIDTH] = '\0';
 558         }
 559         if (book_mark_query_color (edit, cur_line, BOOK_MARK_COLOR))
 560         {
 561             g_snprintf (line_stat, 2, "*");
 562         }
 563     }
 564
 565     if (col + 16 > -edit->start_col)
 566     {
 567         eval_marks (edit, &m1, &m2);
 568
 569         if (row <= edit->total_lines - edit->start_line)
 570         {
 571             off_t tws = 0;
 572             if (tty_use_colors () && visible_tws)
 573             {
 574                 tws = edit_eol (edit, b);
 575                 while (tws > b && ((c = edit_get_byte (edit, tws - 1)) == ' ' || c == '\t'))
 576                     tws--;
 577             }
 578
 579             while (col <= end_col - edit->start_col)
 580             {
 581                 int cw = 1;
 582                 int tab_over = 0;
 583                 gboolean wide_width_char = FALSE;
 584                 gboolean control_char = FALSE;
 585
 586                 p->ch = 0;
 587                 p->style = 0;
 588                 if (q == edit->curs1)
 589                     p->style |= MOD_CURSOR;
 590                 if (q >= m1 && q < m2)
 591                 {
 592                     if (edit->column_highlight)
 593                     {
 594                         long x;
 595
 596                         x = (long) edit_move_forward3 (edit, b, 0, q);
 597                         c1 = min (edit->column1, edit->column2);
 598                         c2 = max (edit->column1, edit->column2);
 599                         if (x >= c1 && x < c2)
 600                             p->style |= MOD_MARKED;
 601                     }
 602                     else
 603                         p->style |= MOD_MARKED;
 604                 }
 605                 if (q == edit->bracket)
 606                     p->style |= MOD_BOLD;
 607                 if (q >= edit->found_start && q < (off_t) (edit->found_start + edit->found_len))
 608                     p->style |= MOD_BOLD;
 609
 610 #ifdef HAVE_CHARSET
 611                 if (edit->utf8)
 612                 {
 613                     c = edit_get_utf (edit, q, &cw);
 614                 }
 615                 else
 616 #endif
 617                 {
 618                     c = edit_get_byte (edit, q);
 619                 }
 620                 /* we don't use bg for mc - fg contains both */
 621                 if (book_mark)
 622                 {
 623                     p->style |= book_mark << 16;
 624                 }
 625                 else
 626                 {
 627                     color = edit_get_syntax_color (edit, q);
 628                     p->style |= color << 16;
 629                 }
 630                 switch (c)
 631                 {
 632                 case '\n':
 633                     col = end_col - edit->start_col + 1;        /* quit */
 634                     break;
 635                 case '\t':
 636                     i = TAB_SIZE - ((int) col % TAB_SIZE);
 637                     tab_over = (end_col - edit->start_col) - (col + i - 1);
 638                     if (tab_over < 0)
 639                         i += tab_over;
 640                     col += i;
 641                     if (tty_use_colors () &&
 642                         ((visible_tabs || (visible_tws && q >= tws)) && enable_show_tabs_tws))
 643                     {
 644                         if (p->style & MOD_MARKED)
 645                             c = p->style;
 646                         else if (book_mark)
 647                             c |= book_mark << 16;
 648                         else
 649                             c = p->style | MOD_WHITESPACE;
 650                         if (i > 2)
 651                         {
 652                             p->ch = '<';
 653                             p->style = c;
 654                             p++;
 655                             while (--i > 1)
 656                             {
 657                                 p->ch = '-';
 658                                 p->style = c;
 659                                 p++;
 660                             }
 661                             p->ch = '>';
 662                             p->style = c;
 663                             p++;
 664                         }
 665                         else if (i > 1)
 666                         {
 667                             p->ch = '<';
 668                             p->style = c;
 669                             p++;
 670                             p->ch = '>';
 671                             p->style = c;
 672                             p++;
 673                         }
 674                         else
 675                         {
 676                             p->ch = '>';
 677                             p->style = c;
 678                             p++;
 679                         }
 680                     }
 681                     else if (tty_use_colors () && visible_tws && q >= tws && enable_show_tabs_tws)
 682                     {
 683                         p->ch = '.';
 684                         p->style |= MOD_WHITESPACE;
 685                         c = p->style & ~MOD_CURSOR;
 686                         p++;
 687                         while (--i)
 688                         {
 689                             p->ch = ' ';
 690                             p->style = c;
 691                             p++;
 692                         }
 693                     }
 694                     else
 695                     {
 696                         p->ch |= ' ';
 697                         c = p->style & ~MOD_CURSOR;
 698                         p++;
 699                         while (--i)
 700                         {
 701                             p->ch = ' ';
 702                             p->style = c;
 703                             p++;
 704                         }
 705                     }
 706                     break;
 707                 case ' ':
 708                     if (tty_use_colors () && visible_tws && q >= tws && enable_show_tabs_tws)
 709                     {
 710                         p->ch = '.';
 711                         p->style |= MOD_WHITESPACE;
 712                         p++;
 713                         col++;
 714                         break;
 715                     }
 716                     /* fallthrough */
 717                 default:
 718 #ifdef HAVE_CHARSET
 719                     if (mc_global.utf8_display)
 720                     {
 721                         if (!edit->utf8)
 722                         {
 723                             c = convert_from_8bit_to_utf_c ((unsigned char) c, edit->converter);
 724                         }
 725                         else
 726                         {
 727                             if (g_unichar_iswide (c))
 728                             {
 729                                 wide_width_char = TRUE;
 730                                 col++;
 731                             }
 732                         }
 733                     }
 734                     else if (edit->utf8)
 735                         c = convert_from_utf_to_current_c (c, edit->converter);
 736                     else
 737                         c = convert_to_display_c (c);
 738 #endif
 739
 740                     /* Caret notation for control characters */
 741                     if (c < 32)
 742                     {
 743                         p->ch = '^';
 744                         p->style = abn_style;
 745                         p++;
 746                         p->ch = c + 0x40;
 747                         p->style = abn_style;
 748                         p++;
 749                         col += 2;
 750                         control_char = TRUE;
 751                         break;
 752                     }
 753                     if (c == 127)
 754                     {
 755                         p->ch = '^';
 756                         p->style = abn_style;
 757                         p++;
 758                         p->ch = '?';
 759                         p->style = abn_style;
 760                         p++;
 761                         col += 2;
 762                         control_char = TRUE;
 763                         break;
 764                     }
 765 #ifdef HAVE_CHARSET
 766                     if (edit->utf8)
 767                     {
 768                         if (g_unichar_isprint (c))
 769                             p->ch = c;
 770                         else
 771                         {
 772                             p->ch = '.';
 773                             p->style = abn_style;
 774                         }
 775                         p++;
 776                     }
 777                     else
 778 #endif
 779                     {
 780                         if ((mc_global.utf8_display && g_unichar_isprint (c)) ||
 781                             (!mc_global.utf8_display && is_printable (c)))
 782                         {
 783                             p->ch = c;
 784                             p++;
 785                         }
 786                         else
 787                         {
 788                             p->ch = '.';
 789                             p->style = abn_style;
 790                             p++;
 791                         }
 792                     }
 793                     col++;
 794                     break;
 795                 }               /* case */
 796
 797                 q++;
 798                 if (cw > 1)
 799                 {
 800                     q += cw - 1;
 801                 }
 802
 803                 if (col > (end_col - edit->start_col + 1))
 804                 {
 805                     if (wide_width_char)
 806                     {
 807                         p--;
 808                         break;
 809                     }
 810                     if (control_char)
 811                     {
 812                         p -= 2;
 813                         break;
 814                     }
 815                 }
 816             }
 817         }
 818     }
 819     else
 820     {
 821         start_col_real = start_col = 0;
 822     }
 823
 824     p->ch = 0;
 825
 826     print_to_widget (edit, row, start_col, start_col_real, end_col, line, line_stat, book_mark);
 827 }
 828
 829 /* --------------------------------------------------------------------------------------------- */
 830
 831 static inline void
 832 edit_draw_this_char (WEdit * edit, off_t curs, long row, long start_column, long end_column)
 833 {
 834     off_t b = edit_bol (edit, curs);
 835
 836     edit_draw_this_line (edit, b, row, start_column, end_column);
 837 }
 838
 839 /* --------------------------------------------------------------------------------------------- */
 840 /** cursor must be in screen for other than REDRAW_PAGE passed in force */
 841
 842 static inline void
 843 render_edit_text (WEdit * edit, long start_row, long start_column, long end_row, long end_column)
 844 {
 845     static long prev_curs_row = 0;
 846     static off_t prev_curs = 0;
 847
 848     Widget *w = WIDGET (edit);
 849     Widget *wh = WIDGET (w->owner);
 850
 851     long row = 0, curs_row;
 852     int force = edit->force;
 853     long b;
 854     int y1, x1, y2, x2;
 855
 856     int last_line;
 857     int last_column;
 858
 859     /* draw only visible region */
 860
 861     last_line = wh->y + wh->lines - 1;
 862
 863     y1 = w->y;
 864     if (y1 > last_line - 1 /* buttonbar */ )
 865         return;
 866
 867     last_column = wh->x + wh->cols - 1;
 868
 869     x1 = w->x;
 870     if (x1 > last_column)
 871         return;
 872
 873     y2 = w->y + w->lines - 1;
 874     if (y2 < wh->y + 1 /* menubar */ )
 875         return;
 876
 877     x2 = w->x + w->cols - 1;
 878     if (x2 < wh->x)
 879         return;
 880
 881     if ((force & REDRAW_IN_BOUNDS) == 0)
 882     {
 883         /* !REDRAW_IN_BOUNDS means to ignore bounds and redraw whole rows */
 884         /* draw only visible region */
 885
 886         if (y2 <= last_line - 1 /* buttonbar */ )
 887             end_row = w->lines - 1;
 888         else if (y1 >= wh->y + 1 /* menubar */ )
 889             end_row = wh->lines - 1 - y1 - 1;
 890         else
 891             end_row = start_row + wh->lines - 1 - 1;
 892
 893         if (x2 <= last_column)
 894             end_column = w->cols - 1;
 895         else if (x1 >= wh->x)
 896             end_column = wh->cols - 1 - x1;
 897         else
 898             end_column = start_column + wh->cols - 1;
 899     }
 900
 901     /*
 902      * If the position of the page has not moved then we can draw the cursor
 903      * character only.  This will prevent line flicker when using arrow keys.
 904      */
 905     if ((force & REDRAW_CHAR_ONLY) == 0 || (force & REDRAW_PAGE) != 0)
 906     {
 907         if ((force & REDRAW_PAGE) != 0)
 908         {
 909             row = start_row;
 910             b = edit_move_forward (edit, edit->start_display, start_row, 0);
 911             while (row <= end_row)
 912             {
 913                 if (key_pending (edit))
 914                     return;
 915                 edit_draw_this_line (edit, b, row, start_column, end_column);
 916                 b = edit_move_forward (edit, b, 1, 0);
 917                 row++;
 918             }
 919         }
 920         else
 921         {
 922             curs_row = edit->curs_row;
 923
 924             if ((force & REDRAW_BEFORE_CURSOR) != 0 && start_row < curs_row)
 925             {
 926                 long upto = curs_row - 1 <= end_row ? curs_row - 1 : end_row;
 927
 928                 row = start_row;
 929                 b = edit->start_display;
 930                 while (row <= upto)
 931                 {
 932                     if (key_pending (edit))
 933                         return;
 934                     edit_draw_this_line (edit, b, row, start_column, end_column);
 935                     b = edit_move_forward (edit, b, 1, 0);
 936                 }
 937             }
 938
 939             /*          if (force & REDRAW_LINE)          ---> default */
 940             b = edit_bol (edit, edit->curs1);
 941             if (curs_row >= start_row && curs_row <= end_row)
 942             {
 943                 if (key_pending (edit))
 944                     return;
 945                 edit_draw_this_line (edit, b, curs_row, start_column, end_column);
 946             }
 947
 948             if ((force & REDRAW_AFTER_CURSOR) != 0 && end_row > curs_row)
 949             {
 950                 row = curs_row + 1 < start_row ? start_row : curs_row + 1;
 951                 b = edit_move_forward (edit, b, 1, 0);
 952                 while (row <= end_row)
 953                 {
 954                     if (key_pending (edit))
 955                         return;
 956                     edit_draw_this_line (edit, b, row, start_column, end_column);
 957                     b = edit_move_forward (edit, b, 1, 0);
 958                     row++;
 959                 }
 960             }
 961
 962             if ((force & REDRAW_LINE_ABOVE) != 0 && curs_row >= 1)
 963             {
 964                 row = curs_row - 1;
 965                 b = edit_move_backward (edit, edit_bol (edit, edit->curs1), 1);
 966                 if (row >= start_row && row <= end_row)
 967                 {
 968                     if (key_pending (edit))
 969                         return;
 970                     edit_draw_this_line (edit, b, row, start_column, end_column);
 971                 }
 972             }
 973
 974             if ((force & REDRAW_LINE_BELOW) != 0 && row < w->lines - 1)
 975             {
 976                 row = curs_row + 1;
 977                 b = edit_bol (edit, edit->curs1);
 978                 b = edit_move_forward (edit, b, 1, 0);
 979                 if (row >= start_row && row <= end_row)
 980                 {
 981                     if (key_pending (edit))
 982                         return;
 983                     edit_draw_this_line (edit, b, row, start_column, end_column);
 984                 }
 985             }
 986         }
 987     }
 988     else if (prev_curs_row < edit->curs_row)
 989     {
 990         /* with the new text highlighting, we must draw from the top down */
 991         edit_draw_this_char (edit, prev_curs, prev_curs_row, start_column, end_column);
 992         edit_draw_this_char (edit, edit->curs1, edit->curs_row, start_column, end_column);
 993     }
 994     else
 995     {
 996         edit_draw_this_char (edit, edit->curs1, edit->curs_row, start_column, end_column);
 997         edit_draw_this_char (edit, prev_curs, prev_curs_row, start_column, end_column);
 998     }
 999
1000     edit->force = 0;
1001
1002     prev_curs_row = edit->curs_row;
1003     prev_curs = edit->curs1;
1004 }
1005
1006 /* --------------------------------------------------------------------------------------------- */
1007
1008 static inline void
1009 edit_render (WEdit * edit, int page, int row_start, int col_start, int row_end, int col_end)
1010 {
1011     if (page)                   /* if it was an expose event, 'page' would be set */
1012         edit->force |= REDRAW_PAGE | REDRAW_IN_BOUNDS;
1013
1014     render_edit_text (edit, row_start, col_start, row_end, col_end);
1015
1016     /*
1017      * edit->force != 0 means a key was pending and the redraw
1018      * was halted, so next time we must redraw everything in case stuff
1019      * was left undrawn from a previous key press.
1020      */
1021     if (edit->force)
1022         edit->force |= REDRAW_PAGE;
1023 }
1024
1025 /* --------------------------------------------------------------------------------------------- */
1026 /*** public functions ****************************************************************************/
1027 /* --------------------------------------------------------------------------------------------- */
1028
1029 void
1030 edit_status (WEdit * edit, gboolean active)
1031 {
1032     int color;
1033
1034     if (edit->fullscreen)
1035     {
1036         color = STATUSBAR_COLOR;
1037         edit_status_fullscreen (edit, color);
1038     }
1039     else
1040     {
1041         color = edit->drag_state != MCEDIT_DRAG_NORMAL ? EDITOR_FRAME_DRAG : active ?
1042             EDITOR_FRAME_ACTIVE : EDITOR_FRAME;
1043         edit_draw_frame (edit, color, active);
1044         edit_status_window (edit);
1045     }
1046
1047     edit_draw_window_icons (edit, color);
1048 }
1049
1050 /* --------------------------------------------------------------------------------------------- */
1051
1052 /** this scrolls the text so that cursor is on the screen */
1053 void
1054 edit_scroll_screen_over_cursor (WEdit * edit)
1055 {
1056     Widget *w = WIDGET (edit);
1057
1058     long p;
1059     long outby;
1060     int b_extreme, t_extreme, l_extreme, r_extreme;
1061
1062     if (w->lines <= 0 || w->cols <= 0)
1063         return;
1064
1065     w->lines -= EDIT_TEXT_VERTICAL_OFFSET;
1066     w->cols -= EDIT_TEXT_HORIZONTAL_OFFSET + option_line_state_width;
1067
1068     if (!edit->fullscreen)
1069     {
1070         w->x++;
1071         w->cols -= 2;
1072         w->y++;
1073         w->lines -= 2;
1074     }
1075
1076     r_extreme = EDIT_RIGHT_EXTREME;
1077     l_extreme = EDIT_LEFT_EXTREME;
1078     b_extreme = EDIT_BOTTOM_EXTREME;
1079     t_extreme = EDIT_TOP_EXTREME;
1080     if (edit->found_len != 0)
1081     {
1082         b_extreme = max (w->lines / 4, b_extreme);
1083         t_extreme = max (w->lines / 4, t_extreme);
1084     }
1085     if (b_extreme + t_extreme + 1 > w->lines)
1086     {
1087         int n;
1088
1089         n = b_extreme + t_extreme;
1090         if (n == 0)
1091             n = 1;
1092         b_extreme = (b_extreme * (w->lines - 1)) / n;
1093         t_extreme = (t_extreme * (w->lines - 1)) / n;
1094     }
1095     if (l_extreme + r_extreme + 1 > w->cols)
1096     {
1097         int n;
1098
1099         n = l_extreme + t_extreme;
1100         if (n == 0)
1101             n = 1;
1102         l_extreme = (l_extreme * (w->cols - 1)) / n;
1103         r_extreme = (r_extreme * (w->cols - 1)) / n;
1104     }
1105     p = edit_get_col (edit) + edit->over_col;
1106     edit_update_curs_row (edit);
1107     outby = p + edit->start_col - w->cols + 1 + (r_extreme + edit->found_len);
1108     if (outby > 0)
1109         edit_scroll_right (edit, outby);
1110     outby = l_extreme - p - edit->start_col;
1111     if (outby > 0)
1112         edit_scroll_left (edit, outby);
1113     p = edit->curs_row;
1114     outby = p - w->lines + 1 + b_extreme;
1115     if (outby > 0)
1116         edit_scroll_downward (edit, outby);
1117     outby = t_extreme - p;
1118     if (outby > 0)
1119         edit_scroll_upward (edit, outby);
1120     edit_update_curs_row (edit);
1121
1122     w->lines += EDIT_TEXT_VERTICAL_OFFSET;
1123     w->cols += EDIT_TEXT_HORIZONTAL_OFFSET + option_line_state_width;
1124     if (!edit->fullscreen)
1125     {
1126         w->x--;
1127         w->cols += 2;
1128         w->y--;
1129         w->lines += 2;
1130     }
1131 }
1132
1133 /* --------------------------------------------------------------------------------------------- */
1134
1135 void
1136 edit_render_keypress (WEdit * edit)
1137 {
1138     edit_render (edit, 0, 0, 0, 0, 0);
1139 }
1140
1141 /* --------------------------------------------------------------------------------------------- */