src/editor/wordproc.c

   1 /*
   2    Word-processor mode for the editor: does dynamic
   3    paragraph formatting.
   4
   5    Copyright (C) 2011
   6    The Free Software Foundation, Inc.
   7
   8    Copyright (C) 1996 Paul Sheer
   9
  10    Writen by:
  11    Paul Sheer, 1996
  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: word-processor mode for the editor: does dynamic paragraph formatting
  31  *  \author Paul Sheer
  32  *  \date 1996
  33  */
  34
  35 #include <config.h>
  36
  37 #include <stdio.h>
  38 #include <stdarg.h>
  39 #include <sys/types.h>
  40 #include <unistd.h>
  41 #include <string.h>
  42 #include <ctype.h>
  43 #include <errno.h>
  44 #include <sys/stat.h>
  45
  46 #include <stdlib.h>
  47
  48 #include "lib/global.h"
  49
  50 #include "src/setup.h"          /* option_tab_spacing */
  51
  52 #include "edit-impl.h"
  53 #include "edit-widget.h"
  54
  55 /*** global variables ****************************************************************************/
  56
  57 /*** file scope macro definitions ****************************************************************/
  58
  59 #define tab_width option_tab_spacing
  60
  61 #define NO_FORMAT_CHARS_START "-+*\\,.;:&>"
  62 #define FONT_MEAN_WIDTH 1
  63
  64 /*** file scope type declarations ****************************************************************/
  65
  66 /*** file scope variables ************************************************************************/
  67
  68 /*** file scope functions ************************************************************************/
  69 /* --------------------------------------------------------------------------------------------- */
  70
  71 static long
  72 line_start (WEdit * edit, long line)
  73 {
  74     long p, l;
  75
  76     l = edit->curs_line;
  77     p = edit->curs1;
  78
  79     if (line < l)
  80         p = edit_move_backward (edit, p, l - line);
  81     else if (line > l)
  82         p = edit_move_forward (edit, p, line - l, 0);
  83
  84     p = edit_bol (edit, p);
  85     while (strchr ("\t ", edit_get_byte (edit, p)))
  86         p++;
  87     return p;
  88 }
  89
  90 /* --------------------------------------------------------------------------------------------- */
  91
  92 static int
  93 bad_line_start (WEdit * edit, long p)
  94 {
  95     int c;
  96     c = edit_get_byte (edit, p);
  97     if (c == '.')
  98     {                           /* `...' is acceptable */
  99         if (edit_get_byte (edit, p + 1) == '.')
 100             if (edit_get_byte (edit, p + 2) == '.')
 101                 return 0;
 102         return 1;
 103     }
 104     if (c == '-')
 105     {
 106         if (edit_get_byte (edit, p + 1) == '-')
 107             if (edit_get_byte (edit, p + 2) == '-')
 108                 return 0;       /* `---' is acceptable */
 109         return 1;
 110     }
 111     if (strchr (NO_FORMAT_CHARS_START, c))
 112         return 1;
 113     return 0;
 114 }
 115
 116 /* --------------------------------------------------------------------------------------------- */
 117 /**
 118  * Find the start of the current paragraph for the purpose of formatting.
 119  * Return position in the file.
 120  */
 121
 122 static long
 123 begin_paragraph (WEdit * edit, int force)
 124 {
 125     long i;
 126     for (i = edit->curs_line - 1; i >= 0; i--)
 127     {
 128         if (line_is_blank (edit, i))
 129         {
 130             i++;
 131             break;
 132         }
 133         if (force)
 134         {
 135             if (bad_line_start (edit, line_start (edit, i)))
 136             {
 137                 i++;
 138                 break;
 139             }
 140         }
 141     }
 142     return edit_move_backward (edit, edit_bol (edit, edit->curs1), edit->curs_line - i);
 143 }
 144
 145 /* --------------------------------------------------------------------------------------------- */
 146 /**
 147  * Find the end of the current paragraph for the purpose of formatting.
 148  * Return position in the file.
 149  */
 150
 151 static long
 152 end_paragraph (WEdit * edit, int force)
 153 {
 154     int i;
 155     for (i = edit->curs_line + 1; i <= edit->total_lines; i++)
 156     {
 157         if (line_is_blank (edit, i))
 158         {
 159             i--;
 160             break;
 161         }
 162         if (force)
 163             if (bad_line_start (edit, line_start (edit, i)))
 164             {
 165                 i--;
 166                 break;
 167             }
 168     }
 169     return edit_eol (edit,
 170                      edit_move_forward (edit, edit_bol (edit, edit->curs1),
 171                                         i - edit->curs_line, 0));
 172 }
 173
 174 /* --------------------------------------------------------------------------------------------- */
 175
 176 static unsigned char *
 177 get_paragraph (WEdit * edit, long p, long q, int indent, int *size)
 178 {
 179     unsigned char *s, *t;
 180 #if 0
 181     t = g_try_malloc ((q - p) + 2 * (q - p) / option_word_wrap_line_length + 10);
 182 #else
 183     t = g_try_malloc (2 * (q - p) + 100);
 184 #endif
 185     if (t == NULL)
 186         return NULL;
 187     for (s = t; p < q; p++, s++)
 188     {
 189         if (indent)
 190             if (edit_get_byte (edit, p - 1) == '\n')
 191                 while (strchr ("\t ", edit_get_byte (edit, p)))
 192                     p++;
 193         *s = edit_get_byte (edit, p);
 194     }
 195     *size = (unsigned long) (s - t);
 196     /* FIXME: all variables related to 'size' should be fixed */
 197     t[*size] = '\n';
 198     return t;
 199 }
 200
 201 /* --------------------------------------------------------------------------------------------- */
 202
 203 static inline void
 204 strip_newlines (unsigned char *t, int size)
 205 {
 206     unsigned char *p = t;
 207     while (size-- != 0)
 208     {
 209         if (*p == '\n')
 210             *p = ' ';
 211         p++;
 212     }
 213 }
 214
 215 /* --------------------------------------------------------------------------------------------- */
 216 /**
 217    This function calculates the number of chars in a line specified to length l in pixels
 218  */
 219
 220 static inline int
 221 next_tab_pos (int x)
 222 {
 223     return x += tab_width - x % tab_width;
 224 }
 225
 226 /* --------------------------------------------------------------------------------------------- */
 227
 228 static inline int
 229 line_pixel_length (unsigned char *t, long b, int l)
 230 {
 231     int x = 0, c, xn = 0;
 232     for (;;)
 233     {
 234         c = t[b];
 235         switch (c)
 236         {
 237         case '\n':
 238             return b;
 239         case '\t':
 240             xn = next_tab_pos (x);
 241             break;
 242         default:
 243             xn = x + 1;
 244             break;
 245         }
 246         if (xn > l)
 247             break;
 248         x = xn;
 249         b++;
 250     }
 251     return b;
 252 }
 253
 254 /* --------------------------------------------------------------------------------------------- */
 255
 256 static int
 257 next_word_start (unsigned char *t, int q, int size)
 258 {
 259     int i;
 260     int saw_ws = 0;
 261
 262     for (i = q; i < size; i++)
 263     {
 264         switch (t[i])
 265         {
 266         case '\n':
 267             return -1;
 268         case '\t':
 269         case ' ':
 270             saw_ws = 1;
 271             break;
 272         default:
 273             if (saw_ws != 0)
 274                 return i;
 275             break;
 276         }
 277     }
 278     return -1;
 279 }
 280
 281 /* --------------------------------------------------------------------------------------------- */
 282 /** find the start of a word */
 283
 284 static inline int
 285 word_start (unsigned char *t, int q, int size)
 286 {
 287     int i = q;
 288     if (t[q] == ' ' || t[q] == '\t')
 289         return next_word_start (t, q, size);
 290     for (;;)
 291     {
 292         int c;
 293         if (!i)
 294             return -1;
 295         c = t[i - 1];
 296         if (c == '\n')
 297             return -1;
 298         if (c == ' ' || c == '\t')
 299             return i;
 300         i--;
 301     }
 302 }
 303
 304 /* --------------------------------------------------------------------------------------------- */
 305 /** replaces ' ' with '\n' to properly format a paragraph */
 306
 307 static inline void
 308 format_this (unsigned char *t, int size, int indent)
 309 {
 310     int q = 0, ww;
 311     strip_newlines (t, size);
 312     ww = option_word_wrap_line_length * FONT_MEAN_WIDTH - indent;
 313     if (ww < FONT_MEAN_WIDTH * 2)
 314         ww = FONT_MEAN_WIDTH * 2;
 315     for (;;)
 316     {
 317         int p;
 318         q = line_pixel_length (t, q, ww);
 319         if (q > size)
 320             break;
 321         if (t[q] == '\n')
 322             break;
 323         p = word_start (t, q, size);
 324         if (p == -1)
 325             q = next_word_start (t, q, size);   /* Return the end of the word if the beginning
 326                                                    of the word is at the beginning of a line
 327                                                    (i.e. a very long word) */
 328         else
 329             q = p;
 330         if (q == -1)            /* end of paragraph */
 331             break;
 332         if (q)
 333             t[q - 1] = '\n';
 334     }
 335 }
 336
 337 /* --------------------------------------------------------------------------------------------- */
 338
 339 static inline void
 340 replace_at (WEdit * edit, long q, int c)
 341 {
 342     edit_cursor_move (edit, q - edit->curs1);
 343     edit_delete (edit, 1);
 344     edit_insert_ahead (edit, c);
 345 }
 346
 347 /* --------------------------------------------------------------------------------------------- */
 348 /** replaces a block of text */
 349
 350 static inline void
 351 put_paragraph (WEdit * edit, unsigned char *t, long p, int indent, int size)
 352 {
 353     long cursor;
 354     int i, c = 0;
 355     cursor = edit->curs1;
 356     if (indent)
 357         while (strchr ("\t ", edit_get_byte (edit, p)))
 358             p++;
 359     for (i = 0; i < size; i++, p++)
 360     {
 361         if (i && indent)
 362         {
 363             if (t[i - 1] == '\n' && c == '\n')
 364             {
 365                 while (strchr ("\t ", edit_get_byte (edit, p)))
 366                     p++;
 367             }
 368             else if (t[i - 1] == '\n')
 369             {
 370                 long curs;
 371                 edit_cursor_move (edit, p - edit->curs1);
 372                 curs = edit->curs1;
 373                 edit_insert_indent (edit, indent);
 374                 if (cursor >= curs)
 375                     cursor += edit->curs1 - p;
 376                 p = edit->curs1;
 377             }
 378             else if (c == '\n')
 379             {
 380                 edit_cursor_move (edit, p - edit->curs1);
 381                 while (strchr ("\t ", edit_get_byte (edit, p)))
 382                 {
 383                     edit_delete (edit, 1);
 384                     if (cursor > edit->curs1)
 385                         cursor--;
 386                 }
 387                 p = edit->curs1;
 388             }
 389         }
 390         c = edit_get_byte (edit, p);
 391         if (c != t[i])
 392             replace_at (edit, p, t[i]);
 393     }
 394     edit_cursor_move (edit, cursor - edit->curs1);      /* restore cursor position */
 395 }
 396
 397 /* --------------------------------------------------------------------------------------------- */
 398
 399 static inline int
 400 test_indent (WEdit * edit, long p, long q)
 401 {
 402     int indent;
 403     indent = edit_indent_width (edit, p++);
 404     if (!indent)
 405         return 0;
 406     for (; p < q; p++)
 407         if (edit_get_byte (edit, p - 1) == '\n')
 408             if (indent != edit_indent_width (edit, p))
 409                 return 0;
 410     return indent;
 411 }
 412
 413 /* --------------------------------------------------------------------------------------------- */
 414 /*** public functions ****************************************************************************/
 415 /* --------------------------------------------------------------------------------------------- */
 416
 417 void
 418 format_paragraph (WEdit * edit, int force)
 419 {
 420     long p, q;
 421     int size;
 422     unsigned char *t;
 423     int indent = 0;
 424     if (option_word_wrap_line_length < 2)
 425         return;
 426     if (line_is_blank (edit, edit->curs_line))
 427         return;
 428     p = begin_paragraph (edit, force);
 429     q = end_paragraph (edit, force);
 430     indent = test_indent (edit, p, q);
 431     t = get_paragraph (edit, p, q, indent, &size);
 432     if (!t)
 433         return;
 434     if (!force)
 435     {
 436         int i;
 437         if (strchr (NO_FORMAT_CHARS_START, *t))
 438         {
 439             g_free (t);
 440             return;
 441         }
 442         for (i = 0; i < size - 1; i++)
 443         {
 444             if (t[i] == '\n')
 445             {
 446                 if (strchr (NO_FORMAT_CHARS_START "\t ", t[i + 1]))
 447                 {
 448                     g_free (t);
 449                     return;
 450                 }
 451             }
 452         }
 453     }
 454     format_this (t, q - p, indent);
 455     put_paragraph (edit, t, p, indent, size);
 456     g_free (t);
 457
 458     /* Scroll left as much as possible to show the formatted paragraph */
 459     edit_scroll_left (edit, -edit->start_col);
 460 }
 461
 462 /* --------------------------------------------------------------------------------------------- */