workbench/classes/zune/texteditor/mcc/Navigation.c

   1 /***************************************************************************
   2
   3  TextEditor.mcc - Textediting MUI Custom Class
   4  Copyright (C) 1997-2000 Allan Odgaard
   5  Copyright (C) 2005-2014 TextEditor.mcc Open Source Team
   6
   7  This library is free software; you can redistribute it and/or
   8  modify it under the terms of the GNU Lesser General Public
   9  License as published by the Free Software Foundation; either
  10  version 2.1 of the License, or (at your option) any later version.
  11
  12  This library is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  Lesser General Public License for more details.
  16
  17  TextEditor class Support Site:  http://www.sf.net/projects/texteditor-mcc
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #include <clib/alib_protos.h>
  24 #include <proto/graphics.h>
  25 #include <proto/intuition.h>
  26 #include <proto/locale.h>
  27
  28 #include "private.h"
  29 #include "Debug.h"
  30
  31 struct pos_info pos;
  32
  33 /// FlowSpace()
  34 LONG FlowSpace(struct InstData *data, UWORD flow, STRPTR text)
  35 {
  36   LONG flowspace = 0;
  37
  38   ENTER();
  39
  40   if(flow != MUIV_TextEditor_Flow_Left)
  41   {
  42     flowspace  = (_mwidth(data->object)-TextLengthNew(&data->tmprp, text, LineCharsWidth(data, text)-1, data->TabSizePixels));
  43     flowspace -= (data->CursorWidth == 6) ? TextLength(&data->tmprp, " ", 1) : data->CursorWidth;
  44     if(flow == MUIV_TextEditor_Flow_Center)
  45     {
  46       flowspace /= 2;
  47     }
  48   }
  49
  50   RETURN(flowspace);
  51   return flowspace;
  52 }
  53
  54 ///
  55 /// CursorOffset()
  56 static LONG CursorOffset(struct InstData *data)
  57 {
  58   struct line_node *line = data->actualline;
  59   STRPTR text = &line->line.Contents[data->CPos_X];
  60   LONG res=0;
  61   LONG lineCharsWidth;
  62
  63   ENTER();
  64
  65   // call TextFitNew() to find out how many chars would fit.
  66   if((lineCharsWidth = LineCharsWidth(data, text)) > 0)
  67   {
  68     struct TextExtent tExtend;
  69     LONG offset = data->pixel_x-FlowSpace(data, line->line.Flow, text);
  70
  71     if(offset < 1)
  72       offset = 1;
  73
  74     res = TextFitNew(&data->tmprp, text, lineCharsWidth, &tExtend, NULL, 1, offset, data->font->tf_YSize, data->TabSizePixels);
  75
  76     // in case of a hard-wrapped line we have to deal with
  77     // the possibility that the user tries to
  78     // select the last char in a line which should normally by a white space
  79     // due to soft-wrapping. So in this case we have to lower res by one so
  80     // that it is not possible to select that last white space. However, for
  81     // a hard wrapped line it still have to be possible to select that last char.
  82     if(lineCharsWidth-res == 0 && text[lineCharsWidth-1] <= ' ')
  83       res--;
  84   }
  85
  86   RETURN(res);
  87   return res;
  88 }
  89
  90 ///
  91 /// GetPosInPixels()
  92 /*---------------------------------------*
  93  * Return the number of pixels to cursor *
  94  *---------------------------------------*/
  95 static LONG GetPosInPixels(struct InstData *data, LONG bytes, LONG x)
  96 {
  97   LONG pos;
  98
  99   ENTER();
 100
 101   pos = TextLengthNew(&data->tmprp, &data->actualline->line.Contents[bytes], x, data->TabSizePixels);
 102
 103   if(data->actualline->line.Contents[data->CPos_X] == '\n')
 104     pos += TextLength(&data->tmprp, " ", 1)/2;
 105   else
 106     pos += TextLengthNew(&data->tmprp, &data->actualline->line.Contents[data->CPos_X], 1, data->TabSizePixels)/2;
 107
 108   pos += FlowSpace(data, data->actualline->line.Flow, &data->actualline->line.Contents[bytes]);
 109
 110   RETURN(pos);
 111   return(pos);
 112 }
 113
 114 ///
 115 /// SetBookmark()
 116 void SetBookmark(struct InstData *data, ULONG nr)
 117 {
 118   ENTER();
 119
 120   if(nr < ARRAY_SIZE(data->bookmarks))
 121   {
 122     data->bookmarks[nr].line = data->actualline;
 123     data->bookmarks[nr].x    = data->CPos_X;
 124   }
 125
 126   LEAVE();
 127 }
 128
 129 ///
 130 /// GotoBookmark()
 131 void GotoBookmark(struct InstData *data, ULONG nr)
 132 {
 133   ENTER();
 134
 135   if(nr < ARRAY_SIZE(data->bookmarks))
 136   {
 137     if(data->bookmarks[nr].line)
 138     {
 139       struct line_node *actual = GetFirstLine(&data->linelist);
 140
 141       while(actual != NULL)
 142       {
 143         if(actual == data->bookmarks[nr].line)
 144         {
 145           data->actualline = actual;
 146           data->CPos_X = data->bookmarks[nr].x;
 147           if(data->CPos_X >= actual->line.Length)
 148             data->CPos_X = actual->line.Length-1;
 149           break;
 150         }
 151         actual = GetNextLine(actual);
 152       }
 153       if(actual == NULL)
 154       {
 155         DoMethod(data->object, MUIM_TextEditor_HandleError, Error_BookmarkHasBeenLost);
 156       }
 157     }
 158     else
 159     {
 160       DoMethod(data->object, MUIM_TextEditor_HandleError, Error_NoBookmarkInstalled);
 161     }
 162   }
 163
 164   LEAVE();
 165 }
 166
 167 ///
 168 /// GoTop()
 169 /*---- CursorUp ---- */
 170 void GoTop(struct InstData *data)
 171 {
 172   ENTER();
 173
 174   data->actualline = GetFirstLine(&data->linelist);
 175   data->CPos_X = 0;
 176
 177   LEAVE();
 178 }
 179
 180 ///
 181 /// GoPreviousLine()
 182 void GoPreviousLine(struct InstData *data)
 183 {
 184   ENTER();
 185
 186   if(data->CPos_X == 0 && HasPrevLine(data->actualline) == TRUE)
 187     data->actualline = GetPrevLine(data->actualline);
 188   data->CPos_X = 0;
 189
 190   LEAVE();
 191 }
 192
 193 ///
 194 /// GoPreviousPage()
 195 void GoPreviousPage(struct InstData *data)
 196 {
 197   ENTER();
 198
 199   if(data->shown == TRUE)
 200   {
 201     OffsetToLines(data, data->CPos_X, data->actualline, &pos);
 202     if(data->pixel_x == 0)
 203       data->pixel_x = GetPosInPixels(data, pos.bytes, pos.x);
 204     if(!(HasPrevLine(data->actualline) == FALSE && pos.lines == 1))
 205     {
 206       LONG lineplacement;
 207       LONG linemove = data->maxlines;
 208       struct line_node *prev;
 209
 210       lineplacement = LineToVisual(data, data->actualline)+pos.lines-1;
 211       if(lineplacement != 1)
 212         linemove = lineplacement-1;
 213       linemove -= pos.lines-1;
 214
 215       while(linemove != 0 && (prev = GetPrevLine(data->actualline)) != NULL && prev->visual <= linemove)
 216       {
 217         data->actualline = prev;
 218         linemove -= data->actualline->visual;
 219       }
 220       data->CPos_X = 0;
 221       if(linemove != 0 && HasPrevLine(data->actualline) == TRUE)
 222       {
 223         if(linemove > 0)
 224         {
 225           data->actualline = GetPrevLine(data->actualline);
 226           linemove = data->actualline->visual-linemove;
 227         }
 228         else
 229         {
 230           linemove = -linemove;
 231         }
 232         while(linemove--)
 233         {
 234           data->CPos_X += LineCharsWidth(data, &data->actualline->line.Contents[data->CPos_X]);
 235         }
 236       }
 237       data->CPos_X += CursorOffset(data);
 238     }
 239     else
 240     {
 241       GoTop(data);
 242     }
 243   }
 244
 245   LEAVE();
 246 }
 247
 248 ///
 249 /// GoUp()
 250 void GoUp(struct InstData *data)
 251 {
 252   ENTER();
 253
 254   if(data->shown == TRUE)
 255   {
 256     OffsetToLines(data, data->CPos_X, data->actualline, &pos);
 257     if(data->pixel_x == 0)
 258     {
 259       data->pixel_x = GetPosInPixels(data, pos.bytes, pos.x);
 260     }
 261     if(pos.lines == 1)
 262     {
 263       if(HasPrevLine(data->actualline) == TRUE)
 264       {
 265         data->actualline = GetPrevLine(data->actualline);
 266         pos.lines = data->actualline->visual+1;
 267       }
 268       else
 269       {
 270 //        data->CPos_X = 0;
 271         LEAVE();
 272         return;
 273       }
 274     }
 275     data->CPos_X = 0;
 276     if(--pos.lines)
 277     {
 278       while(--pos.lines)
 279       {
 280         data->CPos_X += LineCharsWidth(data, &data->actualline->line.Contents[data->CPos_X]);
 281       }
 282       data->CPos_X += CursorOffset(data);
 283     }
 284     else
 285       DisplayBeep(NULL);
 286   }
 287
 288   LEAVE();
 289 }
 290
 291 ///
 292 /// GoBottom()
 293 /*---- CursorDown ---- */
 294 void GoBottom(struct InstData *data)
 295 {
 296   ENTER();
 297
 298   data->actualline = GetLastLine(&data->linelist);
 299   data->CPos_X = data->actualline->line.Length-1;
 300
 301   LEAVE();
 302 }
 303
 304 ///
 305 /// GoNextLine()
 306 void GoNextLine(struct InstData *data)
 307 {
 308   ENTER();
 309
 310   data->CPos_X = 0;
 311   if(HasNextLine(data->actualline) == TRUE)
 312     data->actualline = GetNextLine(data->actualline);
 313   else
 314     data->CPos_X = data->actualline->line.Length-1;
 315
 316   LEAVE();
 317 }
 318
 319 ///
 320 /// GoNextPage()
 321 void GoNextPage(struct InstData *data)
 322 {
 323   ENTER();
 324
 325   if(data->shown == TRUE)
 326   {
 327     OffsetToLines(data, data->CPos_X, data->actualline, &pos);
 328     if(data->pixel_x == 0)
 329       data->pixel_x = GetPosInPixels(data, pos.bytes, pos.x);
 330     if(!(HasNextLine(data->actualline) == FALSE&& pos.lines == data->actualline->visual))
 331     {
 332       LONG lineplacement;
 333       LONG linemove = data->maxlines;
 334
 335       lineplacement = LineToVisual(data, data->actualline)+pos.lines-1;
 336       if(lineplacement != data->maxlines)
 337         linemove = data->maxlines - lineplacement;
 338
 339       linemove += pos.lines-1;
 340       while(linemove != 0 && HasNextLine(data->actualline) == TRUE && data->actualline->visual <= linemove)
 341       {
 342         linemove -= data->actualline->visual;
 343         NextLine(data);
 344       }
 345       if(data->actualline->visual <= linemove)
 346         linemove = data->actualline->visual-1;
 347       data->CPos_X = 0;
 348       while(linemove--)
 349       {
 350         OffsetToLines(data, data->CPos_X, data->actualline, &pos);
 351         data->CPos_X = pos.extra;
 352       }
 353       data->CPos_X += CursorOffset(data);
 354     }
 355     else
 356     {
 357       GoBottom(data);
 358     }
 359   }
 360
 361   LEAVE();
 362 }
 363
 364 ///
 365 /// GoDown()
 366 void GoDown (struct InstData *data)
 367 {
 368   ENTER();
 369
 370   if(data->shown == TRUE)
 371   {
 372     OffsetToLines(data, data->CPos_X, data->actualline, &pos);
 373     if(data->pixel_x == 0)
 374     {
 375       data->pixel_x = GetPosInPixels(data, pos.bytes, pos.x);
 376     }
 377
 378     if(pos.lines == data->actualline->visual)
 379     {
 380       struct line_node *next = GetNextLine(data->actualline);
 381
 382       if(next != NULL)
 383       {
 384         pos.lines = 0;
 385         data->actualline = next;
 386         data->CPos_X  = 0;
 387         data->CPos_X += CursorOffset(data);
 388       }
 389       else
 390       {
 391 //        data->CPos_X = data->actualline->line.Length-1;
 392       }
 393     }
 394     else
 395     {
 396       data->CPos_X  = pos.extra;
 397       data->CPos_X += CursorOffset(data);
 398     }
 399   }
 400
 401   LEAVE();
 402 }
 403
 404 ///
 405 /// GoEndOfLine()
 406 /*---- CursorRight ---- */
 407 void GoEndOfLine(struct InstData *data)
 408 {
 409   ENTER();
 410
 411   if(data->shown == TRUE)
 412   {
 413     LONG c;
 414
 415     OffsetToLines(data, data->CPos_X, data->actualline, &pos);
 416
 417     if((c = LineCharsWidth(data, &data->actualline->line.Contents[pos.bytes])) > 0)
 418       data->CPos_X = pos.bytes + c - 1;
 419     else
 420       data->CPos_X = pos.bytes;
 421   }
 422
 423   LEAVE();
 424 }
 425
 426 ///
 427 /// GoNextWord()
 428 void GoNextWord(struct InstData *data)
 429 {
 430   ENTER();
 431
 432   while(data->CPos_X < data->actualline->line.Length && CheckSep(data, data->actualline->line.Contents[data->CPos_X]) == FALSE)
 433     data->CPos_X++;
 434
 435 FindNextWord:
 436
 437   while(data->CPos_X < data->actualline->line.Length && CheckSep(data, data->actualline->line.Contents[data->CPos_X]) == TRUE)
 438     data->CPos_X++;
 439
 440   if(data->CPos_X == data->actualline->line.Length)
 441   {
 442     struct line_node *next = GetNextLine(data->actualline);
 443
 444     if(next != NULL)
 445     {
 446       data->actualline = next;
 447       data->CPos_X = 0;
 448       goto FindNextWord;
 449     }
 450     else
 451       data->CPos_X--;
 452   }
 453
 454   LEAVE();
 455 }
 456
 457 ///
 458 /// GoNextSentence()
 459 void GoNextSentence(struct InstData *data)
 460 {
 461   ENTER();
 462
 463   while(data->CPos_X < data->actualline->line.Length && CheckSent(data, data->actualline->line.Contents[data->CPos_X]) == FALSE)
 464     data->CPos_X++;
 465   while(data->CPos_X < data->actualline->line.Length && CheckSent(data, data->actualline->line.Contents[data->CPos_X]) == TRUE)
 466     data->CPos_X++;
 467   if(data->CPos_X >= data->actualline->line.Length-1)
 468     NextLine(data);
 469   else
 470   {
 471     while(data->CPos_X < data->actualline->line.Length && data->actualline->line.Contents[data->CPos_X] == ' ')
 472       data->CPos_X++;
 473     if(data->CPos_X == data->actualline->line.Length-1)
 474       NextLine(data);
 475   }
 476
 477   LEAVE();
 478 }
 479
 480 ///
 481 /// GoRight()
 482 void GoRight(struct InstData *data)
 483 {
 484   ENTER();
 485
 486   if(data->CPos_X+1 < data->actualline->line.Length)
 487     data->CPos_X++;
 488   else
 489     NextLine(data);
 490
 491   LEAVE();
 492 }
 493
 494 ///
 495 /// GoStartOfLine()
 496 void GoStartOfLine(struct InstData *data)
 497 {
 498   ENTER();
 499
 500   if(data->shown == TRUE)
 501   {
 502     OffsetToLines(data, data->CPos_X, data->actualline, &pos);
 503     data->CPos_X = pos.bytes;
 504   }
 505
 506   LEAVE();
 507 }
 508
 509 ///
 510 /// GoPreviousWord()
 511 void GoPreviousWord(struct InstData *data)
 512 {
 513   BOOL moved = FALSE;
 514   struct line_node *prev;
 515
 516   ENTER();
 517
 518 FindWord:
 519
 520   if(data->CPos_X > 0 && CheckSep(data, data->actualline->line.Contents[data->CPos_X-1]) == TRUE)
 521   {
 522     data->CPos_X--;
 523     moved = TRUE;
 524   }
 525   while(data->CPos_X > 0 && CheckSep(data, data->actualline->line.Contents[data->CPos_X]) == TRUE)
 526   {
 527     data->CPos_X--;
 528     moved = TRUE;
 529   }
 530   prev = GetPrevLine(data->actualline);
 531   if(data->CPos_X == 0 && prev != NULL && (moved == FALSE || CheckSep(data, data->actualline->line.Contents[0]) == TRUE))
 532   {
 533     data->actualline = prev;
 534     data->CPos_X = data->actualline->line.Length-1;
 535     goto FindWord;
 536   }
 537
 538   while(data->CPos_X > 0 && CheckSep(data, data->actualline->line.Contents[data->CPos_X-1]) == FALSE)
 539     data->CPos_X--;
 540
 541   LEAVE();
 542 }
 543
 544 ///
 545 /// GoPreviousSentence()
 546 void GoPreviousSentence(struct InstData *data)
 547 {
 548   struct line_node *prev;
 549
 550   ENTER();
 551
 552   prev = GetPrevLine(data->actualline);
 553   while(data->CPos_X == 0 && prev != NULL)
 554   {
 555     data->actualline = prev;
 556     data->CPos_X = data->actualline->line.Length-1;
 557     prev = GetPrevLine(prev);
 558   }
 559   if(data->CPos_X != 0)
 560   {
 561     data->CPos_X--;
 562     while(data->CPos_X > 0 && data->actualline->line.Contents[data->CPos_X] == ' ')
 563       data->CPos_X--;
 564     while(data->CPos_X > 0 && CheckSent(data, data->actualline->line.Contents[data->CPos_X]) == TRUE)
 565       data->CPos_X--;
 566     while(data->CPos_X > 0 && CheckSent(data, data->actualline->line.Contents[data->CPos_X]) == FALSE)
 567       data->CPos_X--;
 568     if(data->CPos_X > 0)
 569     {
 570       data->CPos_X++;
 571       while(data->CPos_X < data->actualline->line.Length && data->actualline->line.Contents[data->CPos_X] == ' ')
 572         data->CPos_X++;
 573     }
 574   }
 575
 576   LEAVE();
 577 }
 578
 579 ///
 580 /// GoLeft()
 581 void GoLeft(struct InstData *data)
 582 {
 583   ENTER();
 584
 585   if(data->CPos_X > 0)
 586     data->CPos_X--;
 587   else
 588   {
 589     struct line_node *prev = GetPrevLine(data->actualline);
 590
 591     if(prev != NULL)
 592     {
 593       data->actualline = prev;
 594       data->CPos_X = data->actualline->line.Length-1;
 595     }
 596   }
 597
 598   LEAVE();
 599 }
 600 ///
 601
 602 /// CheckSep()
 603 /*-----------------------------------------*
 604  * Check if given char is a word-seperator *
 605  *-----------------------------------------*/
 606 BOOL CheckSep(struct InstData *data, char character)
 607 {
 608   BOOL isSep = FALSE;
 609
 610   ENTER();
 611
 612   if(!IsAlNum(data->mylocale, (long)character))
 613         isSep = TRUE;
 614
 615   RETURN(isSep);
 616   return isSep;
 617 }
 618
 619 ///
 620 /// CheckSent()
 621 /*-----------------------------------------*
 622  * Check if given char is a sentence ender *
 623  *-----------------------------------------*/
 624 BOOL CheckSent(UNUSED struct InstData *data, char character)
 625 {
 626   BOOL isSent = FALSE;
 627
 628   ENTER();
 629
 630   if(character == '.' || character == '!' || character == '?')
 631     isSent = TRUE;
 632
 633   RETURN(isSent);
 634   return isSent;
 635 }
 636
 637 ///
 638 /// NextLine()
 639 /*-----------------------------------*
 640  * Move cursor to start of next line *
 641  *-----------------------------------*/
 642 void NextLine(struct InstData *data)
 643 {
 644   struct line_node *next;
 645
 646   ENTER();
 647
 648   next = GetNextLine(data->actualline);
 649   if(next != NULL)
 650   {
 651     data->actualline = next;
 652     data->CPos_X = 0;
 653   }
 654   else
 655   {
 656     data->CPos_X = data->actualline->line.Length-1;
 657   }
 658
 659   LEAVE();
 660 }
 661
 662 ///
 663 /// PosFromCursor()
 664 /*-----------------------------------------*
 665  * Place the cursor, based on an X Y coord *
 666  *-----------------------------------------*/
 667 void PosFromCursor(struct InstData *data, LONG MouseX, LONG MouseY)
 668 {
 669   struct pos_info pos;
 670   LONG limit = data->ypos;
 671
 672   ENTER();
 673
 674   if(data->maxlines < data->totallines-data->visual_y+1)
 675     limit += (data->maxlines * data->fontheight);
 676   else
 677     limit += (data->totallines-data->visual_y+1)*data->fontheight;
 678
 679   if(MouseY >= limit)
 680     MouseY = limit-1;
 681
 682   GetLine(data, ((MouseY - data->ypos)/data->fontheight) + data->visual_y, &pos);
 683
 684   data->actualline = pos.line;
 685
 686   data->pixel_x = MouseX-_mleft(data->object)+1;
 687
 688   if(data->pixel_x < 1)
 689     data->pixel_x = 1;
 690
 691   data->CPos_X  = pos.x;
 692   data->CPos_X += CursorOffset(data);
 693   data->pixel_x = 0;
 694
 695   LEAVE();
 696 }
 697
 698 ///