mp_edit.mpsl

   1 /*
   2
   3     Minimum Profit 5.x
   4     A Programmer's Text Editor
   5
   6     Editing.
   7
   8     Copyright (C) 1991-2007 Angel Ortega <angel@triptico.com>
   9
  10     This program is free software; you can redistribute it and/or
  11     modify it under the terms of the GNU General Public License
  12     as published by the Free Software Foundation; either version 2
  13     of the License, or (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with this program; if not, write to the Free Software
  22     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23
  24     http://www.triptico.com
  25
  26 */
  27
  28
  29 /* editor actions */
  30
  31 mp.actions['insert_line']       = sub (d) {
  32         mp.store_undo(d);
  33         mp.insert_newline(d);
  34
  35         if (d.syntax == NULL) mp.detect_syntax(d);
  36 };
  37
  38 mp.actions['delete_line']       = sub (d) { mp.store_undo(d); mp.delete_line(d); };
  39 mp.actions['insert_space']      = sub (d) { mp.store_undo(d); mp.insert_space(d); };
  40 mp.actions['insert_tab']        = sub (d) { mp.store_undo(d); mp.insert_tab(d); };
  41 mp.actions['delete']            = sub (d) { mp.store_undo(d); mp.delete_char(d); };
  42 mp.actions['delete_left']       = sub (d) { mp.store_undo(d); mp.move_left(d) &&
  43                                         mp.delete_char(d); };
  44 mp.actions['undo']              = sub (d) { mp.undo(d); };
  45 mp.actions['redo']              = sub (d) { mp.redo(d); };
  46 mp.actions['join_paragraph']    = sub (d) { mp.store_undo(d); mp.join_paragraph(d); };
  47
  48 mp.actions['word_wrap_paragraph'] = sub (d) {
  49
  50         if(mp.config.word_wrap == 0)
  51                 mp.alert(L("Word wrapping must be set"));
  52         else {
  53                 mp.store_undo(d);
  54                 mp.word_wrap_paragraph(d);
  55         }
  56 };
  57
  58 mp.actions['line_options']      = sub (d) {
  59
  60         /* convert special characters on end of line */
  61         local lt = mp.backslash_codes(mp.config.eol, 1);
  62
  63         local t = mp.form( [
  64                 { 'label'       => L("Word wrap on column (0, no word wrap):"),
  65                   'type'        => 'text',
  66                   'value'       => mp.config.word_wrap,
  67                   'history'     => 'wordwrap' },
  68                 { 'label'       => L("Automatic indentation") ~ ':',
  69                   'type'        => 'checkbox',
  70                   'value'       => mp.config.auto_indent },
  71                 { 'label'       => L("Line termination") ~ ':',
  72                   'value'       => lt,
  73                   'type'        => 'text' },
  74                 { 'label'       => L("Mark end of lines") ~ ':',
  75                   'value'       => mp.config.mark_eol,
  76                   'type'        => 'checkbox' }
  77         ] );
  78
  79         if (t != NULL) {
  80                 mp.config.word_wrap = t[0];
  81                 mp.config.auto_indent = t[1];
  82                 mp.config.eol = mp.backslash_codes(t[2], 0);
  83                 mp.config.mark_eol = t[3];
  84         }
  85 };
  86
  87 mp.actions['tab_options']       = sub (d) {
  88
  89         local t = mp.form( [
  90                 { 'label'       => L("Tab size") ~ ':',
  91                   'type'        => 'text',
  92                   'value'       => mp.config.tab_size,
  93                   'history'     => 'tabsize' },
  94                 { 'label'       => L("Convert tabs to spaces") ~ ':',
  95                   'type'        => 'checkbox',
  96                   'value'       => mp.config.tabs_as_spaces }
  97         ] );
  98
  99         if (t != NULL) {
 100                 mp.config.tab_size = t[0];
 101                 mp.config.tabs_as_spaces = t[1];
 102         }
 103 };
 104
 105 /* default key bindings */
 106
 107 mp.keycodes['enter']    = "insert_line";
 108 mp.keycodes['tab']      = "insert_tab";
 109 mp.keycodes['space']    = "insert_space";
 110 mp.keycodes['delete']   = "delete";
 111 mp.keycodes['backspace']= "delete_left";
 112 mp.keycodes['ctrl-i']   = "insert_tab";
 113 mp.keycodes['ctrl-m']   = "insert_line";
 114 mp.keycodes['ctrl-y']   = "delete_line";
 115 mp.keycodes['ctrl-z']   = "undo";
 116 mp.keycodes['f4']       = "word_wrap_paragraph";
 117 mp.keycodes['f6']       = "join_paragraph";
 118
 119 /* action descriptions */
 120
 121 mp.actdesc['insert_line']       = LL("Insert line");
 122 mp.actdesc['delete_line']       = LL("Delete line");
 123 mp.actdesc['insert_space']      = LL("Insert space");
 124 mp.actdesc['insert_tab']        = LL("Insert tab");
 125 mp.actdesc['delete']            = LL("Delete character");
 126 mp.actdesc['delete_left']       = LL("Delete character to the left");
 127 mp.actdesc['undo']              = LL("Undo");
 128 mp.actdesc['redo']              = LL("Redo");
 129 mp.actdesc['join_paragraph']    = LL("Join a paragraph in one line");
 130 mp.actdesc['word_wrap_paragraph'] = LL("Word-wrap a paragraph");
 131 mp.actdesc['line_options']      = LL("Line options...");
 132 mp.actdesc['tab_options']       = LL("Tab options...");
 133
 134 /* code */
 135
 136 /**
 137  * mp.break_line - Breaks current line in two (inserts a newline).
 138  * @doc: the document
 139  * @col: column where the newline will be inserted
 140  *
 141  * Breaks current line in two by inserting a newline character in between.
 142  * If @col is not NULL, the newline will be inserted in that column; otherwise,
 143  * the current x position will be used.
 144  */
 145 sub mp.break_line(doc, col)
 146 {
 147         local txt = doc.txt;
 148         local c, w;
 149
 150         /* if col is NULL, set it to be the x cursor */
 151         if (col == NULL)
 152                 col = txt.x;
 153
 154         /* gets line where cursor is */
 155         c = txt.lines[txt.y];
 156
 157         /* deletes from col to the end of line */
 158         w = splice(c, NULL, col, -1);
 159
 160         /* set first part as current line */
 161         txt.lines[txt.y] = w[0];
 162
 163         /* move to next line */
 164         txt.y++;
 165
 166         /* insert a new line here */
 167         expand(txt.lines, txt.y, 1);
 168
 169         /* fix the x cursor position */
 170         txt.x -= col;
 171
 172         /* if autoindenting... */
 173         if (mp.config.auto_indent) {
 174                 /* extract leading blanks in the original line
 175                    to prepend them to the line to be inserted */
 176                 local i = regex("/^[ \t]*[-\+\*]?[ \t]+/", c, 0);
 177
 178                 /* substitute all non-tab characters with spaces */
 179                 i = sregex("/[^\t]/g", i, " ");
 180
 181                 /* delete any blank in the new line */
 182                 w[1] = sregex("/^[ \t]*/", w[1]);
 183
 184                 /* concatenate */
 185                 w[1] = i ~ w[1];
 186
 187                 /* the x position is further the length of that */
 188                 txt.x += size(i);
 189         }
 190
 191         /* put second part there (or an empty string if NULL) */
 192         txt.lines[txt.y] = w[1] || '';
 193
 194         txt.mod++;
 195 }
 196
 197
 198 sub mp.join_line(doc)
 199 /* joins the current line with the next one */
 200 {
 201         local txt = doc.txt;
 202
 203         if (txt.y < size(txt.lines)) {
 204                 /* concats current line with the next one */
 205                 txt.lines[txt.y] = txt.lines[txt.y] ~ txt.lines[txt.y + 1];
 206
 207                 /* delete it */
 208                 adel(txt.lines, txt.y + 1);
 209
 210                 txt.mod++;
 211         }
 212 }
 213
 214
 215 sub mp.delete_line(doc)
 216 /* deletes the current line */
 217 {
 218         local txt = doc.txt;
 219         local vx;
 220
 221         /* take current position */
 222         vx = mp.x2vx(txt.lines[txt.y], txt.x);
 223
 224         /* if it's the only line, just replace it */
 225         if (size(txt.lines) == 1)
 226                 txt.lines[0] = '';
 227         else {
 228                 /* destroy the line */
 229                 adel(txt.lines, txt.y);
 230         }
 231
 232         /* fix if it was the last line */
 233         if (txt.y >= size(txt.lines))
 234                 txt.y = size(txt.lines) - 1;
 235
 236         /* move to previous x position */
 237         txt.x = mp.vx2x(txt.lines[txt.y], vx);
 238
 239         txt.mod++;
 240 }
 241
 242
 243 sub mp.delete_char(doc)
 244 /* deletes the current char */
 245 {
 246         local txt = doc.txt;
 247
 248         /* is it over the end of line? */
 249         if (txt.x == size(txt.lines[txt.y]))
 250                 mp.join_line(doc);
 251         else {
 252                 local w;
 253
 254                 w = splice(txt.lines[txt.y], NULL, txt.x, 1);
 255                 txt.lines[txt.y] = w[0];
 256         }
 257
 258         txt.mod++;
 259 }
 260
 261
 262 sub mp.delete_range(doc, bx, by, ex, ey, v)
 263 /* deletes a range of characters from a document */
 264 {
 265         local txt = doc.txt;
 266
 267         /* move to the start of the range */
 268         txt.x = bx;
 269         txt.y = by;
 270
 271         if (by == ey) {
 272                 local w;
 273
 274                 /* block is just one line; delete the middle part */
 275                 w = splice(txt.lines[by], NULL, bx, ex - bx);
 276
 277                 txt.lines[by] = w[0];
 278         }
 279         else {
 280                 /* block has more than one line */
 281                 local w;
 282
 283                 if (v == 0) {
 284                         /* delete using normal selection block */
 285
 286                         /* delete from the beginning to the end of the first line */
 287                         w = splice(txt.lines[by], NULL, bx, -1);
 288                         txt.lines[by] = w[0];
 289
 290                         /* delete from the beginning of the last line to
 291                            the end of the block */
 292                         w = splice(txt.lines[ey], NULL, 0, ex);
 293                         txt.lines[ey] = w[0];
 294
 295                         /* collapse the lines in between */
 296                         collapse(txt.lines, by + 1, ey - by - 1);
 297
 298                         /* finally join both lines */
 299                         mp.join_line(doc);
 300                 }
 301                 else {
 302                         /* delete using vertical selection block */
 303                         while (by <= ey) {
 304                                 w = splice(txt.lines[by], NULL, bx, ex - bx);
 305                                 txt.lines[by] = w[0];
 306                                 by++;
 307                         }
 308                 }
 309         }
 310
 311         txt.mod++;
 312 }
 313
 314
 315 sub mp.insert_string(doc, str)
 316 /* inserts a string into the cursor position */
 317 {
 318         local txt = doc.txt;
 319         local w;
 320
 321         /* splice and change */
 322         w = splice(txt.lines[txt.y], str, txt.x, 0);
 323         txt.lines[txt.y] = w[0];
 324
 325         /* move right */
 326         txt.x += size(str);
 327
 328         txt.mod++;
 329 }
 330
 331
 332 sub mp.insert(doc, a)
 333 /* inserts an array of text into a document */
 334 {
 335         local txt = doc.txt;
 336         local s;
 337
 338         /* if a is not an array, split it */
 339         if (!is_array(a))
 340                 a = split("\n", a);
 341
 342         /* empty array? return */
 343         if ((s = size(a)) == 0)
 344                 return;
 345
 346         /* paste first line into current position */
 347         mp.insert_string(doc, a[0]);
 348
 349         /* more than just one line? */
 350         if (s > 1) {
 351                 /* break current line in two */
 352                 mp.break_line(doc);
 353
 354                 /* insert last line */
 355                 mp.insert_string(doc, a[s - 1]);
 356         }
 357
 358         /* more than two lines? */
 359         if (s > 2) {
 360                 local n = 1;
 361
 362                 /* open room */
 363                 expand(txt.lines, txt.y, s - 2);
 364
 365                 /* transfer middle lines */
 366                 while (n < s - 1)
 367                         txt.lines[txt.y++] = a[n++];
 368         }
 369 }
 370
 371
 372 sub mp.wrap_words(doc)
 373 /* do the word wrapping */
 374 {
 375         local txt = doc.txt;
 376
 377         if (mp.config.word_wrap == 0)
 378                 return;
 379
 380         /* take the column where the cursor is */
 381         local c = mp.x2vx(txt.lines[txt.y], txt.x);
 382
 383         if (c >= mp.config.word_wrap &&
 384                 regex("/^.{1," ~ mp.config.word_wrap ~ "}\s/", txt.lines[txt.y])) {
 385                 local w;
 386
 387                 /* take the coordinates */
 388                 w = regex();
 389
 390                 /* break the line there */
 391                 mp.break_line(doc, w[1]);
 392
 393                 /* delete the space at the end of the line */
 394                 txt.lines[txt.y - 1] = sregex("/\s$/", txt.lines[txt.y - 1], NULL);
 395         }
 396 }
 397
 398
 399 sub mp.insert_space(doc)
 400 /* inserts a space, taking wordwrapping into account */
 401 {
 402         local txt = doc.txt;
 403
 404         mp.wrap_words(doc);
 405         mp.insert(doc, ' ');
 406 }
 407
 408
 409 sub mp.insert_tab(doc)
 410 /* inserts a tab */
 411 {
 412         if (mp.config.tabs_as_spaces) {
 413                 /* number of spaces to insert */
 414                 local n = mp.config.tab_size -
 415                         ((doc.txt.x) % mp.config.tab_size);
 416
 417                 while(n--) mp.insert(doc, ' ');
 418         }
 419         else
 420                 mp.insert(doc, "\t");
 421 }
 422
 423
 424 sub mp.insert_newline(doc)
 425 /* inserts a newline */
 426 {
 427         mp.wrap_words(doc);
 428         mp.break_line(doc);
 429 }
 430
 431
 432 sub mp.insert_keystroke(doc, key)
 433 /* inserts from a keystroke (with undo) */
 434 {
 435         if (size(key) == 1) {
 436                 mp.store_undo(doc);
 437
 438                 mp.insert(doc, key);
 439         }
 440         else
 441         if (key != NULL) {
 442                 mp.message = {
 443                         'timeout'       => time() + 2,
 444                         'string'        => sprintf(L("Unbound keystroke '%s'"), key)
 445                 };
 446         }
 447 }
 448
 449
 450 /* undo */
 451
 452 sub mp.store_undo(doc)
 453 /* stores the current txt in the undo queue */
 454 {
 455         queue(doc.undo, clone(doc.txt), mp.config.undo_levels);
 456         doc.redo = [];
 457 }
 458
 459
 460 sub mp.undo(doc)
 461 /* undoes last operation */
 462 {
 463         local txt;
 464
 465         if (txt = pop(doc.undo)) {
 466                 queue(doc.redo, clone(doc.txt), mp.config.undo_levels);
 467                 doc.txt = txt;
 468         }
 469 }
 470
 471
 472 sub mp.redo(doc)
 473 /* redoes last undid operation */
 474 {
 475         local txt;
 476
 477         if (txt = pop(doc.redo)) {
 478                 queue(doc.undo, clone(doc.txt), mp.config.undo_levels);
 479                 doc.txt = txt;
 480         }
 481 }
 482
 483 /* paragraphs */
 484
 485 sub mp.join_paragraph(doc)
 486 /* joins current paragraph in just one line */
 487 {
 488         local txt = doc.txt;
 489         local l;
 490
 491         while ((l = txt.lines[txt.y + 1]) && size(l)) {
 492                 /* delete all leading blanks in the next line */
 493                 txt.lines[txt.y + 1] = sregex("/^[ \t]+/", txt.lines[txt.y + 1]);
 494
 495                 /* move to end of line and add a space separator */
 496                 mp.move_eol(doc);
 497                 mp.insert(doc, ' ');
 498
 499                 /* really join */
 500                 mp.join_line(doc);
 501         }
 502 }
 503
 504
 505 sub mp.word_wrap_paragraph(doc)
 506 /* word wraps current paragraph */
 507 {
 508         local txt = doc.txt;
 509
 510         if (mp.config.word_wrap == 0)
 511                 return;
 512
 513         mp.join_paragraph(doc);
 514
 515         mp.move_eol(doc);
 516
 517         while (size(txt.lines[txt.y]) > mp.config.word_wrap) {
 518                 mp.insert_space(doc);
 519                 mp.move_left(doc);
 520                 mp.delete_char(doc);
 521         }
 522 }