mp_move.mpsl

   1 /*
   2
   3     Minimum Profit 5.x
   4     A Programmer's Text Editor
   5
   6     Movement.
   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 /** editor actions **/
  29
  30 mp.actions['move_left']         = sub (d) { mp.move(d, mp.move_left); };
  31 mp.actions['move_right']        = sub (d) { mp.move(d, mp.move_right); };
  32 mp.actions['move_up']           = sub (d) { mp.move(d, mp.move_up); };
  33 mp.actions['move_down']         = sub (d) { mp.move(d, mp.move_down); };
  34 mp.actions['move_pgup']         = sub (d) { mp.move(d, mp.move_pgup); };
  35 mp.actions['move_pgdn']         = sub (d) { mp.move(d, mp.move_pgdn); };
  36 mp.actions['move_bol']          = sub (d) { mp.move(d, mp.move_bol); };
  37 mp.actions['move_eol']          = sub (d) { mp.move(d, mp.move_eol); };
  38 mp.actions['move_bof']          = sub (d) { mp.move(d, mp.move_bof); };
  39 mp.actions['move_eof']          = sub (d) { mp.move(d, mp.move_eof); };
  40 mp.actions['move_word_left']    = sub (d) { mp.move(d, mp.move_word_left); };
  41 mp.actions['move_word_right']   = sub (d) { mp.move(d, mp.move_word_right); };
  42
  43 mp.actions['goto']              = sub (d) {
  44         local y = mp.form( [
  45                 { 'label'       => L("Line to go to:"),
  46                   'type'        => 'text',
  47                   'history'     => 'goto' }
  48                 ]);
  49
  50         if (y != NULL && y[0] >= 1) {
  51                 d.txt.x = 0;
  52                 mp.set_y(d, y[0] - 1);
  53         }
  54 };
  55
  56 mp.actions['move_to_mouse_position']    = sub (d) {
  57
  58         /* move the cursor there */
  59         mp.move_to_coords_xy(d, mp.mouse_x, mp.mouse_y);
  60
  61         /* mouse click always unmarks */
  62         mp.unmark(d);
  63 };
  64
  65 mp.actions['move_mouse_wheel_up']       = sub (d) {
  66         mp.move(d, sub (d) {
  67                 mp.move_up(d);
  68                 mp.move_up(d);
  69                 mp.move_up(d);
  70                 mp.move_up(d);
  71         });
  72 };
  73
  74 mp.actions['move_mouse_wheel_down']     = sub (d) {
  75         mp.move(d, sub(d) {
  76                 mp.move_down(d);
  77                 mp.move_down(d);
  78                 mp.move_down(d);
  79                 mp.move_down(d);
  80         });
  81 };
  82
  83 mp.actions['document_list'] = sub (d) {
  84
  85         local r = mp.form( [
  86                 { 'label'       =>      L("Document list"),
  87                   'type'        =>      'list',
  88                   'list'        =>      mp.get_doc_names(60),
  89                   'value'       =>      mp.active_i
  90                 } ]
  91         );
  92
  93         if (r[0] != NULL)
  94                 mp.active_i = r[0];
  95 };
  96
  97 /** default key bindings **/
  98
  99 mp.keycodes['cursor-left']              = "move_left";
 100 mp.keycodes['cursor-right']             = "move_right";
 101 mp.keycodes['cursor-up']                = "move_up";
 102 mp.keycodes['cursor-down']              = "move_down";
 103 mp.keycodes['page-up']                  = "move_pgup";
 104 mp.keycodes['page-down']                = "move_pgdn";
 105 mp.keycodes['home']                     = "move_bol";
 106 mp.keycodes['end']                      = "move_eol";
 107 mp.keycodes['ctrl-home']                = "move_bof";
 108 mp.keycodes['ctrl-end']                 = "move_eof";
 109 mp.keycodes['ctrl-cursor-left']         = "move_word_left";
 110 mp.keycodes['ctrl-cursor-right']        = "move_word_right";
 111 mp.keycodes['ctrl-g']                   = "goto";
 112 mp.keycodes['mouse-left-button']        = "move_to_mouse_position";
 113 mp.keycodes['mouse-right-button']       = "move_to_mouse_position";
 114 mp.keycodes['mouse-middle-button']      = "move_to_mouse_position";
 115 mp.keycodes['mouse-wheel-up']           = "move_mouse_wheel_up";
 116 mp.keycodes['mouse-wheel-down']         = "move_mouse_wheel_down";
 117
 118 /** action descriptions **/
 119
 120 mp.actdesc['move_left']                 = LL("Character left");
 121 mp.actdesc['move_right']                = LL("Character right");
 122 mp.actdesc['move_up']                   = LL("Line up");
 123 mp.actdesc['move_down']                 = LL("Line down");
 124 mp.actdesc['move_pgup']                 = LL("Page up");
 125 mp.actdesc['move_pgdn']                 = LL("Page down");
 126 mp.actdesc['move_bol']                  = LL("Beginning of line");
 127 mp.actdesc['move_eol']                  = LL("End of line");
 128 mp.actdesc['move_bof']                  = LL("Beginning of document");
 129 mp.actdesc['move_eof']                  = LL("End of document");
 130 mp.actdesc['move_word_left']            = LL("Word left");
 131 mp.actdesc['move_word_right']           = LL("Word right");
 132 mp.actdesc['goto']                      = LL("Go to line...");
 133 mp.actdesc['move_to_mouse_position']    = LL("Move cursor to mouse click");
 134 mp.actdesc['move_mouse_wheel_down']     = LL("Mouse wheel up");
 135 mp.actdesc['move_mouse_wheel_up']       = LL("Mouse wheel down");
 136 mp.actdesc['document_list']             = LL("Document list");
 137
 138 /** code **/
 139
 140 sub mp.move(doc, func)
 141 /* wrapper for movement functions, with possible shift selection */
 142 {
 143         if (func != NULL) {
 144                 if (mp.shift_pressed) {
 145                         /* shift pressed? move selecting */
 146                         if (doc.txt.mark == NULL)
 147                                 mp.mark(doc);
 148
 149                         func(doc);
 150                         mp.mark(doc);
 151                 }
 152                 else
 153                         func(doc);
 154         }
 155 }
 156
 157
 158 sub mp.split_by_words(s)
 159 /* splits a string by words */
 160 {
 161         return regex(mp.word_regex ~ 'g', s);
 162 }
 163
 164
 165 sub mp.split_line_by_words(doc, r)
 166 /* splits current line by words and returns a three element array containing
 167    the list of words, the list of offsets and the current position */
 168 {
 169         local txt, l, w, c, ol, oc, p;
 170
 171         txt = doc.txt;
 172         l = txt.lines[txt.y];
 173         ol = [];
 174         oc = [];
 175         p = -1;
 176
 177         /* if no special-purpose regex set, take global one */
 178         if (r == NULL)
 179                 r = mp.word_regex;
 180
 181         while ((w = regex(r, l, c[0] + c[1])) != NULL) {
 182                 /* store the word */
 183                 push(ol, w);
 184
 185                 /* get coordinates */
 186                 c = regex();
 187
 188                 /* push the starting column */
 189                 push(oc, c[0]);
 190
 191                 /* if matching coords are between the cursor, store it */
 192                 if (c[0] <= txt.x && c[0] + c[1] >= txt.x)
 193                         p = size(ol) - 1;
 194         }
 195
 196         /* it txt.x is still further than the last match, it means
 197            that the 'current' position is beyond the last word */
 198         if (txt.x > c[0] + c[1])
 199                 p = size(ol);
 200
 201         /* return the list of words, the list of
 202            coordinates and the current one */
 203         return [ ol, oc, p ];
 204 }
 205
 206
 207 sub mp.get_word(doc, r)
 208 /* returns the word under the cursor */
 209 {
 210         local l = mp.split_line_by_words(doc, r);
 211
 212         /* no word over cursor? */
 213         if (l[2] == -1)
 214                 return NULL;
 215
 216         return l[0][l[2]];
 217 }
 218
 219
 220 sub mp.get_range(doc, bx, by, ex, ey, v)
 221 /* gets a range or characters from a document */
 222 {
 223         local txt = doc.txt;
 224
 225         local r = [];
 226
 227         if (by == ey) {
 228                 local w;
 229
 230                 /* block is just one line; take the inside
 231                    part and push it onto the clipboard */
 232
 233                 w = splice(txt.lines[by], NULL, bx, ex - bx);
 234
 235                 push(r, w[1]);
 236         }
 237         else {
 238                 local w, n;
 239
 240                 /* block has more than one line */
 241
 242                 n = by;
 243                 if (v == 0) {
 244                         /* use normal selection block */
 245
 246                         /* take from the beginning to the end of the first line */
 247                         w = splice(txt.lines[n], NULL, bx, -1);
 248
 249                         push(r, w[1] || '');
 250                         n++;
 251
 252                         /* take the central lines */
 253                         while (n < ey)
 254                                 push(r, txt.lines[n++]);
 255
 256                         /* take the last line */
 257                         w = splice(txt.lines[n], NULL, 0, ex);
 258                         push(r, w[1] || '');
 259                 }
 260                 else {
 261                         /* use vertical selection block */
 262                         while (n <= ey) {
 263                                 w = splice(txt.lines[n++], NULL, bx, ex - bx + 1);
 264                                 local l = w[1];
 265                                 local p = ex - bx - size(l);
 266
 267                                 /* pad out to end of block line */
 268                                 while (p-- >= 0)
 269                                         l = l ~ " ";
 270
 271                                 push(r, l);
 272                         }
 273                 }
 274         }
 275
 276         return r;
 277 }
 278
 279
 280 sub mp.set_x(doc, x)
 281 /* sets the x position */
 282 {
 283         local txt = doc.txt;
 284
 285         if (x < 0) {
 286                 /* cursor moved left of the bol; effective cursor up + eol */
 287                 if (txt.y > 0) {
 288                         /* one line up */
 289                         txt.y--;
 290
 291                         /* set x to the end of the line */
 292                         txt.x = size(txt.lines[txt.y]);
 293                 }
 294         }
 295         else {
 296                 /* test if moved beyond end of line */
 297                 if (x > size(txt.lines[txt.y])) {
 298                         if (txt.y < size(txt.lines) - 1) {
 299                                 /* cursor moved right of eol;
 300                                    effective cursor down + bol */
 301                                 txt.x = 0;
 302                                 txt.y++;
 303                         }
 304                 }
 305                 else
 306                         txt.x = x;
 307         }
 308 }
 309
 310
 311 sub mp.set_y(doc, y)
 312 /* sets the y position */
 313 {
 314         local txt = doc.txt;
 315         local vx;
 316
 317         /* get current visual x position */
 318         vx = mp.x2vx(txt.lines[txt.y], txt.x);
 319
 320         /* set boundaries */
 321         if (y < 0)
 322                 y = 0;
 323         if (y >= size(txt.lines))
 324                 y = size(txt.lines) - 1;
 325
 326         /* move there */
 327         txt.y = y;
 328
 329         /* adjust new x to match previously one */
 330         txt.x = mp.vx2x(txt.lines[txt.y], vx);
 331 }
 332
 333
 334 sub mp.move_up(doc)
 335 /* moves one line up */
 336 {
 337         mp.set_y(doc, doc.txt.y - 1);
 338 }
 339
 340
 341 sub mp.move_down(doc)
 342 /* moves one line down */
 343 {
 344         mp.set_y(doc, doc.txt.y + 1);
 345 }
 346
 347
 348 sub mp.move_pgup(doc)
 349 /* moves one page up */
 350 {
 351         mp.set_y(doc, doc.txt.y - mp.window.ty);
 352 }
 353
 354
 355 sub mp.move_pgdn(doc)
 356 /* moves one page down */
 357 {
 358         mp.set_y(doc, doc.txt.y + mp.window.ty);
 359 }
 360
 361
 362 sub mp.move_left(doc)
 363 /* moves one char left */
 364 {
 365         /* return 0 if on BOF */
 366         if (doc.txt.x + doc.txt.y == 0)
 367                 return 0;
 368
 369         mp.set_x(doc, doc.txt.x - 1);
 370         return 1;
 371 }
 372
 373
 374 sub mp.move_right(doc)
 375 /* moves one char right */
 376 {
 377         mp.set_x(doc, doc.txt.x + 1);
 378 }
 379
 380
 381 sub mp.move_bol(doc)
 382 /* moves to the beginning of the line */
 383 {
 384         doc.txt.x = 0;
 385 }
 386
 387
 388 sub mp.move_eol(doc)
 389 /* moves to the end of the line */
 390 {
 391         doc.txt.x = size(doc.txt.lines[doc.txt.y]);
 392 }
 393
 394
 395 sub mp.move_bof(doc)
 396 /* moves to the beginning of the file */
 397 {
 398         doc.txt.x = 0;
 399         doc.txt.y = 0;
 400 }
 401
 402
 403 sub mp.move_eof(doc)
 404 /* moves to the end of the file */
 405 {
 406         doc.txt.y = size(doc.txt.lines) - 1;
 407         mp.move_eol(doc);
 408 }
 409
 410
 411 sub mp.move_word_left(doc)
 412 /* moves a word to the left */
 413 {
 414         local txt = doc.txt;
 415
 416         while (1) {
 417                 /* split by words */
 418                 local l = mp.split_line_by_words(doc);
 419
 420                 /* get current word */
 421                 local i = l[2];
 422
 423                 if (i >= 0) {
 424                         /* if it's not at the beginning of a word,
 425                            move there and go */
 426                         if (i < size(l[1]) && txt.x != l[1][i]) {
 427                                 txt.x = l[1][i];
 428                                 break;
 429                         }
 430
 431                         /* go to previous word */
 432                         i = l[2] - 1;
 433
 434                         /* if that position exists, move there */
 435                         if (i >= 0) {
 436                                 txt.x = l[1][i];
 437                                 break;
 438                         }
 439                 }
 440
 441                 /* no lines up? exit */
 442                 if (txt.y == 0)
 443                         break;
 444
 445                 txt.y--;
 446                 txt.x = size(txt.lines[txt.y]);
 447         }
 448 }
 449
 450
 451 sub mp.move_word_right(doc)
 452 /* moves a word to the right */
 453 {
 454         local txt = doc.txt;
 455
 456         while (txt.y < size(txt.lines) - 1) {
 457                 /* split by words */
 458                 local l = mp.split_line_by_words(doc);
 459
 460                 /* get next position */
 461                 local i = l[2] + 1;
 462
 463                 /* if that position exists, move there */
 464                 if (i < size(l[1])) {
 465                         txt.x = l[1][i];
 466                         break;
 467                 }
 468
 469                 /* try next line */
 470                 txt.y++;
 471                 txt.x = 0;
 472         }
 473 }
 474
 475
 476 sub mp.move_to_coords_xy(doc, x, y)
 477 /* move the cursor to the character on the visual coords x and y */
 478 {
 479         /* set y */
 480         mp.set_y(doc, doc.txt.vy + y);
 481
 482         /* calculate the real position in that line
 483            where the mouse click seem to be */
 484         x = mp.vx2x(doc.txt.lines[doc.txt.y], doc.txt.vx + x);
 485
 486         /* move there */
 487         mp.set_x(doc, x);
 488 }