src/editor/format.c

   1 /*
   2    Dynamic paragraph formatting.
   3
   4    Copyright (C) 2011-2015
   5    Free Software Foundation, Inc.
   6
   7    Copyright (C) 1996 Paul Sheer
   8
   9    Writen by:
  10    Paul Sheer, 1996
  11    Andrew Borodin <aborodin@vmail.ru>, 2013, 2014
  12
  13    This file is part of the Midnight Commander.
  14
  15    The Midnight Commander is free software: you can redistribute it
  16    and/or modify it under the terms of the GNU General Public License as
  17    published by the Free Software Foundation, either version 3 of the License,
  18    or (at your option) any later version.
  19
  20    The Midnight Commander is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23    GNU General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  27  */
  28
  29 /** \file
  30  *  \brief Source: Dynamic paragraph formatting
  31  *  \author Paul Sheer
  32  *  \date 1996
  33  *  \author Andrew Borodin
  34  *  \date 2013, 2014
  35  */
  36
  37 #include <config.h>
  38
  39 #include <stdio.h>
  40 #include <stdarg.h>
  41 #include <sys/types.h>
  42 #include <unistd.h>
  43 #include <string.h>
  44 #include <ctype.h>
  45 #include <errno.h>
  46 #include <sys/stat.h>
  47
  48 #include <stdlib.h>
  49
  50 #include "lib/global.h"
  51
  52 #include "src/setup.h"          /* option_tab_spacing */
  53
  54 #include "edit-impl.h"
  55 #include "editwidget.h"
  56
  57 /*** global variables ****************************************************************************/
  58
  59 char *option_stop_format_chars = NULL;
  60
  61 /*** file scope macro definitions ****************************************************************/
  62
  63 #define tab_width option_tab_spacing
  64
  65 #define FONT_MEAN_WIDTH 1
  66
  67 /*** file scope type declarations ****************************************************************/
  68
  69 /*** file scope variables ************************************************************************/
  70
  71 /*** file scope functions ************************************************************************/
  72 /* --------------------------------------------------------------------------------------------- */
  73
  74 static off_t
  75 line_start (const edit_buffer_t * buf, long line)
  76 {
  77     off_t p;
  78     long l;
  79
  80     l = buf->curs_line;
  81     p = buf->curs1;
  82
  83     if (line < l)
  84         p = edit_buffer_move_backward (buf, p, l - line);
  85     else if (line > l)
  86         p = edit_buffer_move_forward (buf, p, line - l, 0);
  87
  88     p = edit_buffer_get_bol (buf, p);
  89     while (strchr ("\t ", edit_buffer_get_byte (buf, p)) != NULL)
  90         p++;
  91     return p;
  92 }
  93
  94 /* --------------------------------------------------------------------------------------------- */
  95
  96 static gboolean
  97 bad_line_start (const edit_buffer_t * buf, off_t p)
  98 {
  99     int c;
 100
 101     c = edit_buffer_get_byte (buf, p);
 102     if (c == '.')
 103     {
 104         /* `...' is acceptable */
 105         return !(edit_buffer_get_byte (buf, p + 1) == '.'
 106                  && edit_buffer_get_byte (buf, p + 2) == '.');
 107     }
 108     if (c == '-')
 109     {
 110         /* `---' is acceptable */
 111         return !(edit_buffer_get_byte (buf, p + 1) == '-'
 112                  && edit_buffer_get_byte (buf, p + 2) == '-');
 113     }
 114
 115     return (option_stop_format_chars != NULL && strchr (option_stop_format_chars, c) != NULL);
 116 }
 117
 118 /* --------------------------------------------------------------------------------------------- */
 119 /**
 120  * Find the start of the current paragraph for the purpose of formatting.
 121  * Return position in the file.
 122  */
 123
 124 static off_t
 125 begin_paragraph (WEdit * edit, gboolean force, long *lines)
 126 {
 127     long i;
 128
 129     for (i = edit->buffer.curs_line - 1; i >= 0; i--)
 130         if (edit_line_is_blank (edit, i) ||
 131             (force && bad_line_start (&edit->buffer, line_start (&edit->buffer, i))))
 132         {
 133             i++;
 134             break;
 135         }
 136
 137     *lines = edit->buffer.curs_line - i;
 138
 139     return edit_buffer_move_backward (&edit->buffer, edit_buffer_get_current_bol (&edit->buffer),
 140                                       *lines);
 141 }
 142
 143 /* --------------------------------------------------------------------------------------------- */
 144 /**
 145  * Find the end of the current paragraph for the purpose of formatting.
 146  * Return position in the file.
 147  */
 148
 149 static off_t
 150 end_paragraph (WEdit * edit, gboolean force)
 151 {
 152     long i;
 153
 154     for (i = edit->buffer.curs_line + 1; i <= edit->buffer.lines; i++)
 155         if (edit_line_is_blank (edit, i) ||
 156             (force && bad_line_start (&edit->buffer, line_start (&edit->buffer, i))))
 157         {
 158             i--;
 159             break;
 160         }
 161
 162     return edit_buffer_get_eol (&edit->buffer,
 163                                 edit_buffer_move_forward (&edit->buffer,
 164                                                           edit_buffer_get_current_bol
 165                                                           (&edit->buffer),
 166                                                           i - edit->buffer.curs_line, 0));
 167 }
 168
 169 /* --------------------------------------------------------------------------------------------- */
 170
 171 static GString *
 172 get_paragraph (const edit_buffer_t * buf, off_t p, off_t q, gboolean indent)
 173 {
 174     GString *t;
 175
 176     t = g_string_sized_new (128);
 177
 178     for (; p < q; p++)
 179     {
 180         if (indent && edit_buffer_get_byte (buf, p - 1) == '\n')
 181             while (strchr ("\t ", edit_buffer_get_byte (buf, p)) != NULL)
 182                 p++;
 183
 184         g_string_append_c (t, edit_buffer_get_byte (buf, p));
 185     }
 186
 187     g_string_append_c (t, '\n');
 188
 189     return t;
 190 }
 191
 192 /* --------------------------------------------------------------------------------------------- */
 193
 194 static inline void
 195 strip_newlines (unsigned char *t, off_t size)
 196 {
 197     unsigned char *p;
 198
 199     for (p = t; size-- != 0; p++)
 200         if (*p == '\n')
 201             *p = ' ';
 202 }
 203
 204 /* --------------------------------------------------------------------------------------------- */
 205 /**
 206    This function calculates the number of chars in a line specified to length l in pixels
 207  */
 208
 209 static inline off_t
 210 next_tab_pos (off_t x)
 211 {
 212     x += tab_width - x % tab_width;
 213     return x;
 214 }
 215
 216 /* --------------------------------------------------------------------------------------------- */
 217
 218 static inline off_t
 219 line_pixel_length (unsigned char *t, off_t b, off_t l, gboolean utf8)
 220 {
 221     off_t xn, x;                /* position conters */
 222     off_t char_length;          /* character length in bytes */
 223
 224 #ifndef HAVE_CHARSET
 225     (void) utf8;
 226 #endif
 227
 228     for (xn = 0, x = 0; xn <= l; x = xn, b += char_length)
 229     {
 230         char *tb;
 231
 232         tb = (char *) t + b;
 233         char_length = 1;
 234
 235         switch (tb[0])
 236         {
 237         case '\n':
 238             return b;
 239         case '\t':
 240             xn = next_tab_pos (x);
 241             break;
 242         default:
 243 #ifdef HAVE_CHARSET
 244             if (utf8)
 245             {
 246                 gunichar ch;
 247
 248                 ch = g_utf8_get_char_validated (tb, -1);
 249                 if (ch != (gunichar) (-2) && ch != (gunichar) (-1))
 250                 {
 251                     char *next_ch;
 252
 253                     /* Calculate UTF-8 char length */
 254                     next_ch = g_utf8_next_char (tb);
 255                     if (next_ch != NULL)
 256                         char_length = next_ch - tb;
 257
 258                     if (g_unichar_iswide (ch))
 259                         x++;
 260                 }
 261             }
 262 #endif
 263
 264             xn = x + 1;
 265             break;
 266         }
 267     }
 268
 269     return b;
 270 }
 271
 272 /* --------------------------------------------------------------------------------------------- */
 273
 274 static off_t
 275 next_word_start (unsigned char *t, off_t q, off_t size)
 276 {
 277     off_t i;
 278     gboolean saw_ws = FALSE;
 279
 280     for (i = q; i < size; i++)
 281     {
 282         switch (t[i])
 283         {
 284         case '\n':
 285             return -1;
 286         case '\t':
 287         case ' ':
 288             saw_ws = TRUE;
 289             break;
 290         default:
 291             if (saw_ws)
 292                 return i;
 293             break;
 294         }
 295     }
 296     return (-1);
 297 }
 298
 299 /* --------------------------------------------------------------------------------------------- */
 300 /** find the start of a word */
 301
 302 static inline int
 303 word_start (unsigned char *t, off_t q, off_t size)
 304 {
 305     off_t i;
 306
 307     if (t[q] == ' ' || t[q] == '\t')
 308         return next_word_start (t, q, size);
 309
 310     for (i = q;; i--)
 311     {
 312         unsigned char c;
 313
 314         if (i == 0)
 315             return (-1);
 316         c = t[i - 1];
 317         if (c == '\n')
 318             return (-1);
 319         if (c == ' ' || c == '\t')
 320             return i;
 321     }
 322 }
 323
 324 /* --------------------------------------------------------------------------------------------- */
 325 /** replaces ' ' with '\n' to properly format a paragraph */
 326
 327 static inline void
 328 format_this (unsigned char *t, off_t size, long indent, gboolean utf8)
 329 {
 330     off_t q = 0, ww;
 331
 332     strip_newlines (t, size);
 333     ww = option_word_wrap_line_length * FONT_MEAN_WIDTH - indent;
 334     if (ww < FONT_MEAN_WIDTH * 2)
 335         ww = FONT_MEAN_WIDTH * 2;
 336
 337     while (TRUE)
 338     {
 339         off_t p;
 340
 341         q = line_pixel_length (t, q, ww, utf8);
 342         if (q > size)
 343             break;
 344         if (t[q] == '\n')
 345             break;
 346         p = word_start (t, q, size);
 347         if (p == -1)
 348             q = next_word_start (t, q, size);   /* Return the end of the word if the beginning
 349                                                    of the word is at the beginning of a line
 350                                                    (i.e. a very long word) */
 351         else
 352             q = p;
 353         if (q == -1)            /* end of paragraph */
 354             break;
 355         if (q != 0)
 356             t[q - 1] = '\n';
 357     }
 358 }
 359
 360 /* --------------------------------------------------------------------------------------------- */
 361
 362 static inline void
 363 replace_at (WEdit * edit, off_t q, int c)
 364 {
 365     edit_cursor_move (edit, q - edit->buffer.curs1);
 366     edit_delete (edit, TRUE);
 367     edit_insert_ahead (edit, c);
 368 }
 369
 370 /* --------------------------------------------------------------------------------------------- */
 371
 372 static long
 373 edit_indent_width (const WEdit * edit, off_t p)
 374 {
 375     off_t q = p;
 376
 377     /* move to the end of the leading whitespace of the line */
 378     while (strchr ("\t ", edit_buffer_get_byte (&edit->buffer, q)) != NULL
 379            && q < edit->buffer.size - 1)
 380         q++;
 381     /* count the number of columns of indentation */
 382     return (long) edit_move_forward3 (edit, p, 0, q);
 383 }
 384
 385 /* --------------------------------------------------------------------------------------------- */
 386
 387 static void
 388 edit_insert_indent (WEdit * edit, long indent)
 389 {
 390     if (!option_fill_tabs_with_spaces)
 391         while (indent >= TAB_SIZE)
 392         {
 393             edit_insert (edit, '\t');
 394             indent -= TAB_SIZE;
 395         }
 396
 397     while (indent-- > 0)
 398         edit_insert (edit, ' ');
 399 }
 400
 401 /* --------------------------------------------------------------------------------------------- */
 402 /** replaces a block of text */
 403
 404 static inline void
 405 put_paragraph (WEdit * edit, unsigned char *t, off_t p, long indent, off_t size)
 406 {
 407     off_t cursor;
 408     off_t i;
 409     int c = '\0';
 410
 411     cursor = edit->buffer.curs1;
 412     if (indent != 0)
 413         while (strchr ("\t ", edit_buffer_get_byte (&edit->buffer, p)) != NULL)
 414             p++;
 415     for (i = 0; i < size; i++, p++)
 416     {
 417         if (i != 0 && indent != 0)
 418         {
 419             if (t[i - 1] == '\n' && c == '\n')
 420             {
 421                 while (strchr ("\t ", edit_buffer_get_byte (&edit->buffer, p)) != NULL)
 422                     p++;
 423             }
 424             else if (t[i - 1] == '\n')
 425             {
 426                 off_t curs;
 427
 428                 edit_cursor_move (edit, p - edit->buffer.curs1);
 429                 curs = edit->buffer.curs1;
 430                 edit_insert_indent (edit, indent);
 431                 if (cursor >= curs)
 432                     cursor += edit->buffer.curs1 - p;
 433                 p = edit->buffer.curs1;
 434             }
 435             else if (c == '\n')
 436             {
 437                 edit_cursor_move (edit, p - edit->buffer.curs1);
 438                 while (strchr ("\t ", edit_buffer_get_byte (&edit->buffer, p)) != NULL)
 439                 {
 440                     edit_delete (edit, TRUE);
 441                     if (cursor > edit->buffer.curs1)
 442                         cursor--;
 443                 }
 444                 p = edit->buffer.curs1;
 445             }
 446         }
 447
 448         c = edit_buffer_get_byte (&edit->buffer, p);
 449         if (c != t[i])
 450             replace_at (edit, p, t[i]);
 451     }
 452 }
 453
 454 /* --------------------------------------------------------------------------------------------- */
 455
 456 static inline long
 457 test_indent (const WEdit * edit, off_t p, off_t q)
 458 {
 459     long indent;
 460
 461     indent = edit_indent_width (edit, p++);
 462     if (indent == 0)
 463         return 0;
 464
 465     for (; p < q; p++)
 466         if (edit_buffer_get_byte (&edit->buffer, p - 1) == '\n'
 467             && indent != edit_indent_width (edit, p))
 468             return 0;
 469     return indent;
 470 }
 471
 472 /* --------------------------------------------------------------------------------------------- */
 473 /*** public functions ****************************************************************************/
 474 /* --------------------------------------------------------------------------------------------- */
 475
 476 void
 477 format_paragraph (WEdit * edit, gboolean force)
 478 {
 479     off_t p, q;
 480     long lines;
 481     off_t size;
 482     GString *t;
 483     long indent;
 484     unsigned char *t2;
 485     gboolean utf8 = FALSE;
 486
 487     if (option_word_wrap_line_length < 2)
 488         return;
 489     if (edit_line_is_blank (edit, edit->buffer.curs_line))
 490         return;
 491
 492     p = begin_paragraph (edit, force, &lines);
 493     q = end_paragraph (edit, force);
 494     indent = test_indent (edit, p, q);
 495
 496     t = get_paragraph (&edit->buffer, p, q, indent != 0);
 497     size = t->len - 1;
 498
 499     if (!force)
 500     {
 501         off_t i;
 502         char *stop_format_chars;
 503
 504         if (option_stop_format_chars != NULL
 505             && strchr (option_stop_format_chars, t->str[0]) != NULL)
 506         {
 507             g_string_free (t, TRUE);
 508             return;
 509         }
 510
 511         if (option_stop_format_chars == NULL || *option_stop_format_chars == '\0')
 512             stop_format_chars = g_strdup ("\t");
 513         else
 514             stop_format_chars = g_strconcat (option_stop_format_chars, "\t", (char *) NULL);
 515
 516         for (i = 0; i < size - 1; i++)
 517             if (t->str[i] == '\n' && strchr (stop_format_chars, t->str[i + 1]) != NULL)
 518             {
 519                 g_free (stop_format_chars);
 520                 g_string_free (t, TRUE);
 521                 return;
 522             }
 523
 524         g_free (stop_format_chars);
 525     }
 526
 527     t2 = (unsigned char *) g_string_free (t, FALSE);
 528 #ifdef HAVE_CHARSET
 529     utf8 = edit->utf8;
 530 #endif
 531     /* scroll up to show 1st line of paragraph */
 532     edit_move_up (edit, lines, TRUE);
 533     /* scroll left as much as possible to show the formatted paragraph */
 534     edit_scroll_left (edit, -edit->start_col);
 535
 536     format_this (t2, q - p, indent, utf8);
 537     put_paragraph (edit, t2, p, indent, size);
 538     g_free ((char *) t2);
 539
 540     /* move to the end of paragraph */
 541     q = end_paragraph (edit, force);
 542     edit_cursor_move (edit, q - edit->buffer.curs1);
 543
 544     /* try move to the start of next paragraph */
 545     if (edit->buffer.curs_line < edit->buffer.lines)
 546     {
 547         edit_execute_cmd (edit, CK_Home, -1);
 548
 549         do
 550         {
 551             edit_execute_cmd (edit, CK_Down, -1);
 552         }
 553         while (edit->buffer.curs_line < edit->buffer.lines
 554                && edit_line_is_blank (edit, edit->buffer.curs_line));
 555     }
 556 }
 557
 558 /* --------------------------------------------------------------------------------------------- */