workbench/classes/zune/texteditor/mcc/MixedFunctions.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 <string.h>
  24
  25 #include <graphics/gfxmacros.h>
  26 #include <graphics/text.h>
  27 #include <libraries/mui.h>
  28 #include <clib/alib_protos.h>
  29 #include <proto/graphics.h>
  30 #include <proto/layers.h>
  31 #include <proto/exec.h>
  32 #include <proto/intuition.h>
  33
  34 #include <proto/muimaster.h>
  35
  36 /*************************************************************************/
  37
  38 #include "private.h"
  39 #include "Debug.h"
  40
  41 /// AddClipping()
  42 void AddClipping(struct InstData *data)
  43 {
  44   ENTER();
  45
  46   if(data->clipcount == 0)
  47   {
  48     data->cliphandle = MUI_AddClipping(muiRenderInfo(data->object), _mleft(data->object), _mtop(data->object), _mwidth(data->object), _mheight(data->object));
  49   }
  50   data->clipcount++;
  51
  52   LEAVE();
  53 }
  54
  55 ///
  56 /// RemoveClipping()
  57 void RemoveClipping(struct InstData *data)
  58 {
  59   ENTER();
  60
  61   data->clipcount--;
  62   if(data->clipcount == 0)
  63   {
  64     MUI_RemoveClipping(muiRenderInfo(data->object), data->cliphandle);
  65   }
  66
  67   LEAVE();
  68 }
  69
  70 ///
  71 /// FreeTextMem
  72 void FreeTextMem(struct InstData *data, struct MinList *lines)
  73 {
  74   struct line_node *line;
  75
  76   ENTER();
  77
  78   while((line = RemFirstLine(lines)) != NULL)
  79   {
  80     FreeVecPooled(data->mypool, line->line.Contents);
  81     if(line->line.Styles != NULL)
  82       FreeVecPooled(data->mypool, line->line.Styles);
  83     if(line->line.Colors != NULL)
  84       FreeVecPooled(data->mypool, line->line.Colors);
  85
  86     FreeVecPooled(data->mypool, line);
  87   }
  88
  89   InitLines(lines);
  90
  91   LEAVE();
  92 }
  93
  94 ///
  95 /// Init_LineNode()
  96 /*-----------------------------------*
  97  * Initializes a line_node structure *
  98  *-----------------------------------*/
  99 BOOL Init_LineNode(struct InstData *data, struct line_node *line, CONST_STRPTR text)
 100 {
 101   BOOL success = FALSE;
 102   LONG textlength;
 103   const char *p;
 104   char *ctext;
 105
 106   ENTER();
 107
 108   textlength = 0;
 109   p = text;
 110   while(*p != '\n' && *p != '\0')
 111   {
 112     p++;
 113     textlength++;
 114   }
 115   // count one byte more for the trailing LF byte
 116   textlength++;
 117
 118   // and allocate yet another additional byte for the trailing NUL byte
 119   if((ctext = AllocVecPooled(data->mypool, textlength+1)) != NULL)
 120   {
 121     strlcpy(ctext, text, textlength+1);
 122
 123     line->line.Contents = ctext;
 124     line->line.Length = textlength;
 125     line->line.allocatedContents = textlength+1;
 126     if(data->rport != NULL)
 127       line->visual = VisualHeight(data, line);
 128     line->line.Highlight = FALSE;
 129     line->line.Styles = NULL;
 130     line->line.Colors = NULL;
 131     line->line.Flow = MUIV_TextEditor_Flow_Left;
 132     line->line.Separator = LNSF_None;
 133
 134     success = TRUE;
 135   }
 136
 137   RETURN(success);
 138   return(success);
 139 }
 140
 141 ///
 142 /// ExpandLine()
 143 BOOL ExpandLine(struct InstData *data, struct line_node *line, LONG length)
 144 {
 145   BOOL result = FALSE;
 146   char *newbuffer;
 147   LONG expandedSize;
 148
 149   ENTER();
 150
 151   if(line->line.allocatedContents >= 2 && line->line.Length >= line->line.allocatedContents)
 152   {
 153     E(DBF_STYLE, "line length (%ld) > allocated size (%ld)", line->line.Length, line->line.allocatedContents-1);
 154   }
 155
 156   expandedSize = line->line.allocatedContents+40+length;
 157
 158   if((newbuffer = AllocVecPooled(data->mypool, expandedSize)) != NULL)
 159   {
 160     strlcpy(newbuffer, line->line.Contents, expandedSize);
 161     FreeVecPooled(data->mypool, line->line.Contents);
 162     line->line.Contents = newbuffer;
 163     line->line.allocatedContents = expandedSize;
 164     result = TRUE;
 165   }
 166
 167   RETURN(result);
 168   return result;
 169 }
 170
 171 ///
 172 /// CompressLine()
 173 BOOL CompressLine(struct InstData *data, struct line_node *line)
 174 {
 175   BOOL result = FALSE;
 176   LONG compressedSize;
 177
 178   ENTER();
 179
 180   compressedSize = strlen(line->line.Contents)+1;
 181   if(compressedSize < line->line.allocatedContents)
 182   {
 183     char *newbuffer;
 184
 185     if((newbuffer = AllocVecPooled(data->mypool, compressedSize)) != NULL)
 186     {
 187       strlcpy(newbuffer, line->line.Contents, compressedSize);
 188       FreeVecPooled(data->mypool, line->line.Contents);
 189       line->line.Contents = newbuffer;
 190       line->line.Length = strlen(newbuffer);
 191       line->line.allocatedContents = compressedSize;
 192       result = TRUE;
 193     }
 194   }
 195   else
 196   {
 197     // no compression necessary
 198     result = TRUE;
 199   }
 200
 201   RETURN(result);
 202   return result;
 203 }
 204
 205 ///
 206 /// InsertLines
 207 void InsertLines(struct MinList *lines, struct line_node *after)
 208 {
 209   struct line_node *line;
 210
 211   ENTER();
 212
 213   // insert all lines backwards after the given line
 214   // this will effectively add all lines in exactly the same order
 215   while((line = RemLastLine(lines)) != NULL)
 216   {
 217     InsertLine(line, after);
 218   }
 219
 220   LEAVE();
 221 }
 222
 223 ///
 224 /// LineCharsWidth()
 225 /*-----------------------------------------------------*
 226  * Returns the number of chars that will fit on a line *
 227  *-----------------------------------------------------*/
 228 LONG LineCharsWidth(struct InstData *data, CONST_STRPTR text)
 229 {
 230   LONG c;
 231   LONG textlen;
 232   LONG width = _mwidth(data->object);
 233
 234   ENTER();
 235
 236   textlen = text != NULL ? strlen(text)-1 : 0; // the last char is always a "\n"
 237
 238   // check the innerwidth as well. But we also check if we need to
 239   // take care of any of the word wrapping techniques we provide
 240   if(width > 0 && textlen > 0 && data->WrapMode != MUIV_TextEditor_WrapMode_NoWrap)
 241   {
 242     struct TextExtent tExtend;
 243     ULONG fontheight = data->font ? data->font->tf_YSize : 0;
 244
 245     // see how many chars of our text fit to the current innerwidth of the
 246     // texteditor
 247     c = TextFitNew(&data->tmprp, text, textlen, &tExtend, NULL, 1, width, fontheight, data->TabSizePixels);
 248     if(c >= textlen)
 249     {
 250       // if all text fits, then we have to do the calculations once more and
 251       // see if also the ending cursor might fit on the line
 252       width -= (data->CursorWidth == 6) ? TextLength(&data->tmprp, " ", 1) : data->CursorWidth;
 253       c = TextFitNew(&data->tmprp, text, textlen, &tExtend, NULL, 1, width, fontheight, data->TabSizePixels);
 254     }
 255
 256     // if the user selected soft wrapping with a defined wrapborder
 257     // we have to check if we take that border or do the soft wrapping
 258     // at the innerwidth of the texteditor
 259     if(data->WrapBorder > 0 && c > data->WrapBorder && data->WrapMode == MUIV_TextEditor_WrapMode_SoftWrap)
 260       c = data->WrapBorder;
 261
 262     // now we check whether all chars fit on the current innerwidth
 263     // or if we have to do soft word wrapping by searching for the last
 264     // occurance of a linear white space character
 265     if(c < textlen)
 266     {
 267       if(data->WrapWords)
 268       {
 269         LONG tc = c-1;
 270
 271             // search backwards for a linear whitespace (LWSP)
 272             while(tc >= 0 && text[tc] != ' ' && text[tc] != '\t')
 273               tc--;
 274
 275         if(tc >= 0)
 276           c = tc+1;
 277       }
 278     }
 279     else
 280     {
 281       // otherwise always +1 because an ending line should always contain the cursor
 282       c++;
 283     }
 284   }
 285   else
 286     c = textlen+1;
 287
 288   RETURN(c);
 289   return c;
 290 }
 291
 292 ///
 293 /// VisualHeight()
 294 /*-------------------------------------------------------*
 295  * Return the number of visual lines that the line fills *
 296  *-------------------------------------------------------*/
 297 ULONG VisualHeight(struct InstData *data, struct line_node *line)
 298 {
 299   ULONG lines = 0;
 300
 301   ENTER();
 302
 303   if(isFlagSet(data->flags, FLG_HScroll))
 304     lines = 1;
 305   else
 306   {
 307     ULONG c=0;
 308     ULONG length = strlen(line->line.Contents);
 309
 310     while(c < length)
 311     {
 312       LONG d = LineCharsWidth(data, &line->line.Contents[c]);
 313
 314       if(d > 0)
 315         c += d;
 316       else
 317         break;
 318
 319       lines++;
 320     }
 321   }
 322
 323   RETURN(lines);
 324   return(lines);
 325 }
 326
 327 ///
 328 /// OffsetToLines()
 329 /*-----------------------------------------*
 330  * Convert an xoffset to a number of lines *
 331  *-----------------------------------------*/
 332 void OffsetToLines(struct InstData *data, LONG x, struct line_node *line, struct pos_info *pos)
 333 {
 334   ENTER();
 335
 336   if(data->shown == TRUE)
 337   {
 338     LONG c = 0;
 339     LONG d = 0;
 340     LONG lines = 0;
 341
 342     while(c <= x)
 343     {
 344       LONG e = LineCharsWidth(data, &line->line.Contents[c]);
 345
 346       d = c;
 347
 348       if(e > 0)
 349       {
 350         c += e;
 351         lines++;
 352       }
 353       else
 354         break;
 355     }
 356
 357     pos->lines = lines;
 358     pos->x     = x - d;
 359     pos->bytes = d;
 360     pos->extra = c;
 361   }
 362   else
 363   {
 364     pos->lines = 1;
 365     pos->x     = x;
 366     pos->bytes = 0;
 367     pos->extra = line->line.Length-1;
 368   }
 369
 370   LEAVE();
 371 }
 372
 373 ///
 374 /// LineNr()
 375 LONG LineNr(struct InstData *data, struct line_node *line)
 376 {
 377   LONG result = 1;
 378   struct line_node *actual = GetFirstLine(&data->linelist);
 379
 380   ENTER();
 381
 382   while(line != actual)
 383   {
 384     result++;
 385     actual = GetNextLine(actual);
 386   }
 387
 388   RETURN(result);
 389   return(result);
 390 }
 391
 392 ///
 393 /// LineNode()
 394 struct line_node *LineNode(struct InstData *data, LONG linenr)
 395 {
 396   struct line_node *actual = GetFirstLine(&data->linelist);
 397   struct line_node *next;
 398
 399   ENTER();
 400
 401   while(--linenr && (next = GetNextLine(actual)) != NULL)
 402   {
 403     actual = next;
 404   }
 405
 406   RETURN(actual);
 407   return(actual);
 408 }
 409
 410 ///
 411 /// SetCursor()
 412 /*------------------*
 413  * Place the cursor *
 414  *------------------*/
 415 void SetCursor(struct InstData *data, LONG x, struct line_node *line, BOOL Set)
 416 {
 417   unsigned char chars[4] = "   \0";
 418   LONG line_nr;
 419   struct pos_info pos;
 420   LONG xplace;
 421   LONG yplace;
 422   LONG cursorxplace;
 423   LONG cursor_width;
 424   BOOL clipping = FALSE;
 425   struct RastPort *rp = data->rport;
 426
 427   UWORD styles[3] = {0, 0, 0};
 428   UWORD colors[3] = {0, 0, 0};
 429   LONG start = 0;
 430   LONG stop = 0;
 431   LONG c;
 432   UWORD flow;
 433
 434   ENTER();
 435
 436   if(Enabled(data) ||
 437      data->update == FALSE ||
 438      (data->scrollaction == TRUE && Set == TRUE) ||
 439      data->ypos != _mtop(data->object) ||
 440      data->shown == FALSE ||
 441      isFlagSet(data->flags, FLG_ReadOnly) ||
 442      isFlagSet(data->flags, FLG_Quiet) ||
 443      isFlagSet(data->flags, FLG_Ghosted))
 444   {
 445     data->cursor_shown = FALSE;
 446
 447     LEAVE();
 448     return;
 449   }
 450
 451   line_nr = LineToVisual(data, line) - 1;
 452   OffsetToLines(data, x, line, &pos);
 453
 454   if(line_nr + pos.lines <= data->maxlines && line_nr + pos.lines > 0)
 455   {
 456     for(c = -1; c < 2; c++)
 457     {
 458       if(x+c >= pos.bytes && x+c < pos.extra)
 459       {
 460         if(c < start)
 461           start = c;
 462         if(c > stop)
 463           stop = c;
 464
 465         styles[c+1] = GetStyle(x+c, line);
 466         colors[c+1] = GetColor(x+c, line);
 467         chars[c+1] = (line->line.Contents[x+c] != '\n') ? line->line.Contents[x+c] : ' ';
 468       }
 469     }
 470
 471     // calculate the cursor width
 472     // if it is set to 6 then we should find out how the width of the current char is
 473     if(data->CursorWidth == 6)
 474       cursor_width = TextLengthNew(&data->tmprp, (chars[1] < ' ') ? (char *)" " : (char *)&chars[1], 1, data->TabSizePixels);
 475     else
 476       cursor_width = data->CursorWidth;
 477
 478     xplace  = _mleft(data->object) + TextLengthNew(&data->tmprp, &line->line.Contents[x-pos.x], pos.x+start, data->TabSizePixels);
 479     flow = FlowSpace(data, line->line.Flow, &line->line.Contents[pos.bytes]);
 480     xplace += flow;
 481     yplace  = data->ypos + (data->fontheight * (line_nr + pos.lines - 1));
 482     cursorxplace = xplace + TextLengthNew(&data->tmprp, &line->line.Contents[x+start], 0-start, data->TabSizePixels);
 483
 484     //D(DBF_STARTUP, "xplace: %ld, yplace: %ld cplace: %ld, innerwidth: %ld width: %ld %ld", xplace, yplace, cursorxplace, _mwidth(data->object), _width(data->object), _mleft(data->object));
 485
 486     if(xplace <= _mright(data->object))
 487     {
 488       // clear area near the cursor first
 489       DoMethod(data->object, MUIM_DrawBackground, xplace, yplace,
 490                                                   TextLengthNew(&data->tmprp, start == 0 ? (STRPTR)chars+1 : (STRPTR)chars, stop-start+1, data->TabSizePixels),
 491                                                   data->fontheight,
 492                                                   cursorxplace - (isFlagSet(data->flags, FLG_InVGrp) ? _mleft(data->object) : 0),
 493                                                   (isFlagSet(data->flags, FLG_InVGrp) ? 0 : _mtop(data->object)) + data->fontheight*(data->visual_y+line_nr+pos.lines-2),
 494                                                   0);
 495
 496       if(Set == TRUE ||
 497          (data->inactiveCursor == TRUE && isFlagClear(data->flags, FLG_Active) && isFlagClear(data->flags, FLG_Activated)))
 498       {
 499         SetAPen(rp, MUIPEN(data->cursorcolor));
 500         SetDrMd(rp, JAM2);
 501
 502         // if the gadget is in inactive state we just draw a skeleton cursor instead
 503         if(data->inactiveCursor == TRUE && isFlagClear(data->flags, FLG_Active) && isFlagClear(data->flags, FLG_Activated))
 504         {
 505           LONG cwidth = cursor_width;
 506
 507           if(data->CursorWidth != 6)
 508             cwidth = TextLengthNew(&data->tmprp, chars[1] < ' ' ? (char *)" " : (char *)&chars[1], 1, data->TabSizePixels);
 509
 510           if(Set == TRUE || data->currentCursorState != CS_INACTIVE)
 511           {
 512             // draw a "new" skeleton cursor
 513             Move(rp, cursorxplace, yplace);
 514             Draw(rp, cursorxplace+cwidth-1, yplace);
 515             Draw(rp, cursorxplace+cwidth-1, yplace+data->fontheight-1);
 516             Draw(rp, cursorxplace, yplace+data->fontheight-1);
 517             Draw(rp, cursorxplace, yplace);
 518           }
 519
 520           // remember the inactive state
 521           data->currentCursorState = CS_INACTIVE;
 522         }
 523         else
 524         {
 525           // draw a normal cursor
 526           RectFill(rp, cursorxplace, yplace, cursorxplace+cursor_width-1, yplace+data->fontheight-1);
 527
 528           // remember the active state
 529           data->currentCursorState = CS_ACTIVE;
 530         }
 531       }
 532       else
 533       {
 534         // remember the off state
 535         data->currentCursorState = CS_OFF;
 536       }
 537
 538       SetDrMd(rp, JAM1);
 539       SetFont(rp, data->font);
 540       Move(rp, xplace, yplace + rp->TxBaseline);
 541
 542       if(data->font->tf_Flags & FPF_PROPORTIONAL)
 543       {
 544         clipping = TRUE;
 545         AddClipping(data);
 546       }
 547
 548       for(c = start; c <= stop; c++)
 549       {
 550         SetAPen(rp, ConvertPen(data, colors[1+c], line->line.Highlight));
 551         SetSoftStyle(rp, ConvertStyle(styles[1+c]), AskSoftStyle(rp));
 552         TextNew(rp, (STRPTR)&chars[1+c], 1, data->TabSizePixels);
 553       }
 554       SetSoftStyle(rp, FS_NORMAL, AskSoftStyle(rp));
 555
 556       /* This is really bad code!!! */
 557       if(line->line.Separator != LNSF_None)
 558       {
 559         LONG LeftX, LeftWidth;
 560         LONG RightX, RightWidth;
 561         LONG Y, Height;
 562
 563         LeftX = _mleft(data->object);
 564         LeftWidth = flow-3;
 565         RightX = _mleft(data->object) + flow + TextLengthNew(&data->tmprp, &line->line.Contents[pos.bytes], pos.extra-pos.bytes-1, data->TabSizePixels) + 3;
 566         RightWidth = _mleft(data->object)+_mwidth(data->object) - RightX;
 567         Y = yplace;
 568         Height = isFlagSet(line->line.Separator, LNSF_Thick) ? 2 : 1;
 569
 570         if(isFlagSet(line->line.Separator, LNSF_Middle))
 571           Y += (data->fontheight/2)-Height;
 572         else if(isFlagSet(line->line.Separator, LNSF_Bottom))
 573           Y += data->fontheight-(2*Height);
 574
 575         if(isFlagSet(line->line.Separator, LNSF_StrikeThru) || line->line.Length == 1)
 576         {
 577           LeftWidth = _mwidth(data->object);
 578         }
 579         else
 580         {
 581           DrawSeparator(data, rp, RightX, Y, RightWidth, Height);
 582         }
 583         DrawSeparator(data, rp, LeftX, Y, LeftWidth, Height);
 584       }
 585
 586       if(clipping)
 587         RemoveClipping(data);
 588     }
 589   }
 590
 591   LEAVE();
 592 }
 593
 594 ///
 595 /// DumpText()
 596 /*-----------------------------------------*
 597  * Dump text from buffer and out to screen *
 598  *-----------------------------------------*/
 599 void DumpText(struct InstData *data, LONG visual_y, LONG line_nr, LONG lines, BOOL doublebuffer)
 600 {
 601   struct pos_info pos;
 602   struct line_node *line;
 603   LONG x;
 604   BOOL drawbottom = (visual_y + (lines-line_nr) - 1) > data->totallines;
 605
 606   ENTER();
 607
 608   if(data->update == TRUE && data->shown == TRUE && isFlagClear(data->flags, FLG_Quiet))
 609   {
 610     GetLine(data, visual_y, &pos);
 611     line = pos.line;
 612     x = pos.x;
 613
 614     if(lines-line_nr < 3 || doublebuffer == TRUE)
 615     {
 616       doublebuffer = TRUE;
 617     }
 618     else
 619     {
 620       AddClipping(data);
 621       doublebuffer = FALSE;
 622     }
 623
 624     while(line != NULL && line_nr != lines)
 625     {
 626       while(x < line->line.Length && line_nr != lines)
 627         x = x + PrintLine(data, x, line, ++line_nr, doublebuffer);
 628
 629       line = GetNextLine(line);
 630       x = 0;
 631     }
 632
 633     if(drawbottom && (data->maxlines > (data->totallines-data->visual_y+1)))
 634     {
 635       DoMethod(data->object, MUIM_DrawBackground,
 636             _mleft(data->object),
 637             data->ypos+((data->totallines-data->visual_y+1)*data->fontheight),
 638             _mwidth(data->object),
 639             (data->maxlines*data->fontheight) - ((data->totallines-data->visual_y+1)*data->fontheight),
 640             (isFlagSet(data->flags, FLG_InVGrp) ? 0 : _mleft(data->object)),
 641             (isFlagSet(data->flags, FLG_InVGrp) ? 0 : _mtop(data->object)) + data->totallines*data->fontheight,
 642             0);
 643
 644       if(isFlagSet(data->flags, FLG_Ghosted) && isFlagClear(data->flags, FLG_MUI4))
 645       {
 646         UWORD newPattern[2];
 647
 648         if(((data->visual_y-1)*data->fontheight)%2 == 0)
 649         {
 650           newPattern[0] = 0x4444;
 651           newPattern[1] = 0x1111;
 652         }
 653         else
 654         {
 655           newPattern[0] = 0x1111;
 656           newPattern[1] = 0x4444;
 657         }
 658         SetDrMd(data->rport, JAM1);
 659         SetAPen(data->rport, _pens(data->object)[MPEN_SHADOW]);
 660         SetAfPt(data->rport, newPattern, 1);
 661         RectFill(data->rport,
 662               _mleft(data->object),
 663               data->ypos+((data->totallines-data->visual_y+1)*data->fontheight),
 664               _mright(data->object),
 665               data->ypos+((data->totallines-data->visual_y+1)*data->fontheight)+(data->maxlines*data->fontheight) - ((data->totallines-data->visual_y+1)*data->fontheight)-1);
 666         SetAfPt(data->rport, NULL, (UBYTE)-1);
 667       }
 668     }
 669
 670     if(doublebuffer == FALSE)
 671       RemoveClipping(data);
 672   }
 673
 674   LEAVE();
 675 }
 676
 677 ///
 678 /// ScrollUpDOwn()
 679 void ScrollUpDown(struct InstData *data)
 680 {
 681   ENTER();
 682
 683   if(data->update == TRUE && isFlagClear(data->flags, FLG_Quiet) && data->shown == TRUE)
 684   {
 685     DumpText(data, data->visual_y, 0, data->maxlines, FALSE);
 686   }
 687
 688   LEAVE();
 689 }
 690
 691 ///
 692 /// GetLine()
 693 /*----------------------------------------------*
 694  * Find a line and fillout a pos_info structure *
 695  *----------------------------------------------*/
 696 void GetLine(struct InstData *data, LONG realline, struct pos_info *pos)
 697 {
 698   struct line_node *line = GetFirstLine(&data->linelist);
 699   struct line_node *next;
 700   LONG x = 0;
 701
 702   ENTER();
 703
 704   while(realline > line->visual && (next = GetNextLine(line)) != NULL)
 705   {
 706     realline = realline - line->visual;
 707     line = next;
 708   }
 709
 710   pos->line = line;
 711   pos->lines = realline;
 712
 713   if(HasNextLine(line) == FALSE && realline > line->visual)
 714   {
 715     x = line->line.Length-1;
 716   }
 717   else if(realline > 0)
 718   {
 719     while(--realline)
 720     {
 721       x += LineCharsWidth(data, &line->line.Contents[x]);
 722     }
 723   }
 724
 725   pos->x = x;
 726
 727   LEAVE();
 728 }
 729
 730 ///
 731 /// LineToVisual()
 732 /*----------------------------*
 733  * Find visual line on screen *
 734  *----------------------------*/
 735 LONG LineToVisual(struct InstData *data, struct line_node *line)
 736 {
 737   LONG  line_nr = 2 - data->visual_y;   // Top line!
 738   struct line_node *tline = GetFirstLine(&data->linelist);
 739
 740   ENTER();
 741
 742   while(tline != line && tline != NULL)
 743   {
 744     line_nr = line_nr + tline->visual;
 745     tline = GetNextLine(tline);
 746   }
 747
 748   RETURN(line_nr);
 749   return(line_nr);
 750 }
 751
 752 ///
 753 /// CountLines
 754 // count all lines in the list and return the number of visual lines
 755 LONG CountLines(struct InstData *data, struct MinList *lines)
 756 {
 757   LONG lineCount = 0;
 758   struct line_node *line;
 759
 760   ENTER();
 761
 762   line = GetFirstLine(lines);
 763   while(line != NULL)
 764   {
 765     LONG vh;
 766
 767     vh = VisualHeight(data, line);
 768     lineCount += vh;
 769     line->visual = vh;
 770     line = GetNextLine(line);
 771   }
 772
 773   RETURN(lineCount);
 774   return lineCount;
 775 }
 776
 777 ///