git.oblomov.eu Git - wine/blob - dlls/riched20/caret.c

   1 /*
   2  * RichEdit - Caret and selection functions.
   3  *
   4  * Copyright 2004 by Krzysztof Foltman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21
  22 #include "editor.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
  25
  26 void ME_GetSelection(ME_TextEditor *editor, int *from, int *to)
  27 {
  28   *from = ME_GetCursorOfs(editor, 0);
  29   *to =   ME_GetCursorOfs(editor, 1);
  30
  31   if (*from > *to)
  32   {
  33     int tmp = *from;
  34     *from = *to;
  35     *to = tmp;
  36   }
  37 }
  38
  39 int ME_GetTextLength(ME_TextEditor *editor)
  40 {
  41   return ME_CharOfsFromRunOfs(editor, ME_FindItemBack(editor->pBuffer->pLast, diRun), 0);
  42 }
  43
  44 void ME_SetSelection(ME_TextEditor *editor, int from, int to)
  45 {
  46   if (from == 0 && to == -1)
  47   {
  48     editor->pCursors[1].pRun = ME_FindItemFwd(editor->pBuffer->pFirst, diRun);
  49     editor->pCursors[1].nOffset = 0;
  50     editor->pCursors[0].pRun = ME_FindItemBack(editor->pBuffer->pLast, diRun);
  51     editor->pCursors[0].nOffset = 0;
  52     ME_Repaint(editor);
  53     ME_ClearTempStyle(editor);
  54     return;
  55   }
  56   if (from == -1)
  57   {
  58     editor->pCursors[1] = editor->pCursors[0];
  59     ME_Repaint(editor);
  60     ME_ClearTempStyle(editor);
  61     return;
  62   }
  63   if (from>to)
  64   {
  65     int tmp = from;
  66     from = to;
  67     to = tmp;
  68   }
  69   ME_RunOfsFromCharOfs(editor, from, &editor->pCursors[1].pRun, &editor->pCursors[1].nOffset);
  70   ME_RunOfsFromCharOfs(editor, to, &editor->pCursors[0].pRun, &editor->pCursors[0].nOffset);
  71 }
  72
  73 void ME_MoveCaret(ME_TextEditor *editor)
  74 {
  75   HDC hDC = GetDC(editor->hWnd);
  76   ME_Context c;
  77
  78   ME_Cursor *pCursor = &editor->pCursors[0];
  79   ME_DisplayItem *pCursorRun = pCursor->pRun;
  80   ME_DisplayItem *pSizeRun = pCursor->pRun;
  81
  82   ME_InitContext(&c, editor, hDC);
  83   assert(!pCursor->nOffset || !editor->bCaretAtEnd);
  84
  85   if (pCursorRun->type == diRun) {
  86     ME_DisplayItem *row = ME_FindItemBack(pCursorRun, diStartRowOrParagraph);
  87     if (row) {
  88       ME_DisplayItem *run = pCursorRun;
  89       ME_DisplayItem *para;
  90       SIZE sz = {0, 0};
  91       if (!pCursor->nOffset && !editor->bCaretAtEnd)
  92       {
  93         ME_DisplayItem *prev = ME_FindItemBack(pCursorRun, diRunOrStartRow);
  94         if (prev->type == diRun)
  95           pSizeRun = prev;
  96       }
  97       assert(row->type == diStartRow); /* paragraph -> run without start row ?*/
  98       para = ME_FindItemBack(row, diParagraph);
  99       if (editor->bCaretAtEnd && !pCursor->nOffset &&
 100           run == ME_FindItemFwd(row, diRun))
 101       {
 102         ME_DisplayItem *tmp = ME_FindItemBack(row, diRunOrParagraph);
 103         if (tmp->type == diRun)
 104         {
 105           row = ME_FindItemBack(tmp, diStartRow);
 106           pSizeRun = run = tmp;
 107           sz = ME_GetRunSize(&c, &run->member.run, ME_StrLen(run->member.run.strText));
 108         }
 109       }
 110       if (pCursor->nOffset && !(run->member.run.nFlags & MERF_SKIPPED)) {
 111         sz = ME_GetRunSize(&c, &run->member.run, pCursor->nOffset);
 112       }
 113       CreateCaret(editor->hWnd, NULL, 0, pSizeRun->member.run.nAscent+pSizeRun->member.run.nDescent);
 114       SetCaretPos(run->member.run.pt.x+sz.cx,
 115         para->member.para.nYPos+row->member.row.nBaseline+pSizeRun->member.run.pt.y-pSizeRun->member.run.nAscent-ME_GetYScrollPos(editor));
 116     } else {
 117       assert(0 == "Wrapped paragraph run without a row?");
 118       CreateCaret(editor->hWnd, NULL, 0, 10);
 119       SetCaretPos(0,0);
 120     }
 121   }
 122   else {
 123     assert(0 == "Cursor not on a run");
 124     CreateCaret(editor->hWnd, NULL, 0, 10); /* FIXME use global font */
 125     SetCaretPos(0,0);
 126   }
 127   ME_DestroyContext(&c);
 128   ReleaseDC(editor->hWnd, hDC);
 129 }
 130
 131 void ME_ShowCaret(ME_TextEditor *ed)
 132 {
 133   ME_MoveCaret(ed);
 134   ShowCaret(ed->hWnd);
 135 }
 136
 137 void ME_HideCaret(ME_TextEditor *ed)
 138 {
 139   HideCaret(ed->hWnd);
 140   DestroyCaret();
 141 }
 142
 143 void ME_InternalDeleteText(ME_TextEditor *editor, int nOfs,
 144   int nChars)
 145 {
 146   ME_Cursor c;
 147   int shift = 0;
 148
 149   while(nChars > 0)
 150   {
 151     ME_Run *run;
 152     ME_CursorFromCharOfs(editor, nOfs, &c);
 153     run = &c.pRun->member.run;
 154     if (run->nFlags & MERF_ENDPARA) {
 155       if (!ME_FindItemFwd(c.pRun, diParagraph))
 156       {
 157         return;
 158       }
 159       ME_JoinParagraphs(editor, ME_GetParagraph(c.pRun));
 160       /* ME_SkipAndPropagateCharOffset(p->pRun, shift); */
 161       ME_CheckCharOffsets(editor);
 162       nChars--;
 163       continue;
 164     }
 165     else
 166     {
 167       ME_Cursor cursor;
 168       int nIntendedChars = nChars;
 169       int nCharsToDelete = nChars;
 170       int i;
 171       int loc = c.nOffset;
 172
 173       ME_FindItemBack(c.pRun, diParagraph)->member.para.nFlags |= MEPF_REWRAP;
 174
 175       cursor = c;
 176       ME_StrRelPos(run->strText, loc, &nChars);
 177       /* nChars is the number of characters that should be deleted from the
 178          FOLLOWING runs (these AFTER cursor.pRun)
 179          nCharsToDelete is a number of chars to delete from THIS run */
 180       nCharsToDelete -= nChars;
 181       shift -= nCharsToDelete;
 182       TRACE("Deleting %d (intended %d-remaning %d) chars at %d in '%s' (%d)\n",
 183         nCharsToDelete, nIntendedChars, nChars, c.nOffset,
 184         debugstr_w(run->strText->szData), run->strText->nLen);
 185
 186       if (!c.nOffset && ME_StrVLen(run->strText) == nCharsToDelete)
 187       {
 188         /* undo = reinsert whole run */
 189         /* nOfs is a character offset (from the start of the document
 190            to the current (deleted) run */
 191         ME_UndoItem *pUndo = ME_AddUndoItem(editor, diUndoInsertRun, c.pRun);
 192         if (pUndo)
 193           pUndo->di.member.run.nCharOfs = nOfs;
 194       }
 195       else
 196       {
 197         /* undo = reinsert partial run */
 198         ME_UndoItem *pUndo = ME_AddUndoItem(editor, diUndoInsertRun, c.pRun);
 199         if (pUndo) {
 200           ME_DestroyString(pUndo->di.member.run.strText);
 201           pUndo->di.member.run.nCharOfs = nOfs;
 202           pUndo->di.member.run.strText = ME_MakeStringN(run->strText->szData+c.nOffset, nCharsToDelete);
 203         }
 204       }
 205       TRACE("Post deletion string: %s (%d)\n", debugstr_w(run->strText->szData), run->strText->nLen);
 206       TRACE("Shift value: %d\n", shift);
 207       ME_StrDeleteV(run->strText, c.nOffset, nCharsToDelete);
 208
 209       /* update cursors (including c) */
 210       for (i=-1; i<editor->nCursors; i++) {
 211         ME_Cursor *pThisCur = editor->pCursors + i;
 212         if (i == -1) pThisCur = &c;
 213         if (pThisCur->pRun == cursor.pRun) {
 214           if (pThisCur->nOffset > cursor.nOffset) {
 215             if (pThisCur->nOffset-cursor.nOffset < nCharsToDelete)
 216               pThisCur->nOffset = cursor.nOffset;
 217             else
 218               pThisCur->nOffset -= nCharsToDelete;
 219             assert(pThisCur->nOffset >= 0);
 220             assert(pThisCur->nOffset <= ME_StrVLen(run->strText));
 221           }
 222           if (pThisCur->nOffset == ME_StrVLen(run->strText))
 223           {
 224             pThisCur->pRun = ME_FindItemFwd(pThisCur->pRun, diRunOrParagraphOrEnd);
 225             assert(pThisCur->pRun->type == diRun);
 226             pThisCur->nOffset = 0;
 227           }
 228         }
 229       }
 230
 231       /* c = updated data now */
 232
 233       if (c.pRun == cursor.pRun)
 234         ME_SkipAndPropagateCharOffset(c.pRun, shift);
 235       else
 236         ME_PropagateCharOffset(c.pRun, shift);
 237
 238       if (!ME_StrVLen(cursor.pRun->member.run.strText))
 239       {
 240         TRACE("Removing useless run\n");
 241         ME_Remove(cursor.pRun);
 242         ME_DestroyDisplayItem(cursor.pRun);
 243       }
 244
 245       shift = 0;
 246       /*
 247       ME_CheckCharOffsets(editor);
 248       */
 249       continue;
 250     }
 251   }
 252 }
 253
 254 void ME_DeleteTextAtCursor(ME_TextEditor *editor, int nCursor,
 255   int nChars)
 256 {
 257   assert(nCursor>=0 && nCursor<editor->nCursors);
 258   ME_InternalDeleteText(editor, ME_GetCursorOfs(editor, nCursor), nChars);
 259 }
 260
 261 static WCHAR wszSpace[] = {' ', 0};
 262
 263 /* FIXME this is temporary, just to have something to test how bad graphics handler is */
 264 void ME_InsertGraphicsFromCursor(ME_TextEditor *editor, int nCursor)
 265 {
 266   ME_Cursor *pCursor = &editor->pCursors[nCursor];
 267   ME_DisplayItem *pItem = NULL;
 268   ME_DisplayItem *pNewRun = NULL;
 269   ME_Style *pStyle = ME_GetInsertStyle(editor, nCursor);
 270   ME_UndoItem *pUndo;
 271
 272   /* FIXME no no no */
 273   if (ME_IsSelection(editor))
 274     ME_DeleteSelection(editor);
 275
 276   pUndo = ME_AddUndoItem(editor, diUndoDeleteRun, NULL);
 277   if (pUndo) {
 278     pUndo->nStart = pCursor->nOffset + pCursor->pRun->member.run.nCharOfs + ME_GetParagraph(pCursor->pRun)->member.para.nCharOfs;
 279     pUndo->nLen = 1;
 280   }
 281   if (pCursor->nOffset)
 282   {
 283     ME_SplitRunSimple(editor, pCursor->pRun, pCursor->nOffset);
 284   }
 285   pItem = pCursor->pRun;
 286   pNewRun = ME_MakeRun(pStyle, ME_MakeStringN(wszSpace, 1), MERF_GRAPHICS);
 287   pNewRun->member.run.nCharOfs = pCursor->pRun->member.run.nCharOfs;
 288   ME_InsertBefore(pCursor->pRun, pNewRun);
 289   ME_PropagateCharOffset(pItem, 1);
 290   ME_CheckCharOffsets(editor);
 291   ME_SendSelChange(editor);
 292 }
 293
 294 void ME_InsertTextFromCursor(ME_TextEditor *editor, int nCursor,
 295   const WCHAR *str, int len, ME_Style *style)
 296 {
 297   const WCHAR *pos;
 298   ME_Cursor *p = NULL;
 299
 300   assert(style);
 301   editor->bCaretAtEnd = FALSE;
 302
 303   ME_AddRefStyle(style);
 304
 305   /* FIXME really HERE ? */
 306   if (ME_IsSelection(editor))
 307     ME_DeleteSelection(editor);
 308
 309   assert(nCursor>=0 && nCursor<editor->nCursors);
 310   if (len == -1)
 311     len = lstrlenW(str);
 312   pos = str;
 313   /* FIXME this sucks - no respect for unicode (what else can be a line separator in unicode?) */
 314   while(pos-str < len && *pos != '\r' && *pos != '\n')
 315     pos++;
 316   /* handle EOLs */
 317   if (pos-str < len) {
 318     ME_DisplayItem *tp, *end_run;
 319     ME_Paragraph *para;
 320     ME_Style *tmp_style;
 321     if (pos!=str)
 322       ME_InsertTextFromCursor(editor, nCursor, str, pos-str, style);
 323     p = &editor->pCursors[nCursor];
 324     tp = ME_FindItemBack(p->pRun, diParagraph);
 325     para = &tp->member.para;
 326     assert(tp);
 327     if (p->nOffset) {
 328       ME_SplitRunSimple(editor, p->pRun, p->nOffset);
 329       p = &editor->pCursors[nCursor];
 330     }
 331     tmp_style = ME_GetInsertStyle(editor, nCursor);
 332     /* ME_SplitParagraph increases style refcount */
 333     tp = ME_SplitParagraph(editor, p->pRun, p->pRun->member.run.style);
 334     p->pRun = ME_FindItemFwd(tp, diRun);
 335     end_run = ME_FindItemBack(tp, diRun);
 336     ME_ReleaseStyle(end_run->member.run.style);
 337     end_run->member.run.style = tmp_style;
 338     p->nOffset = 0;
 339     if(pos-str < len && *pos =='\r')
 340       pos++;
 341     if(pos-str < len && *pos =='\n')
 342       pos++;
 343     if(pos-str < len) {
 344       ME_InsertTextFromCursor(editor, nCursor, pos, len-(pos-str), style);
 345     }
 346     ME_ReleaseStyle(style);
 347     return;
 348   }
 349   p = &editor->pCursors[nCursor];
 350   if (style) {
 351     ME_DisplayItem *pNewRun = NULL;
 352
 353     assert(p->pRun->type == diRun);
 354     pNewRun = ME_MakeRun(style, ME_MakeStringN(str, len), 0); /* addrefs style */
 355     ME_InsertRun(editor, ME_CharOfsFromRunOfs(editor, p->pRun, p->nOffset), pNewRun);
 356     ME_DestroyDisplayItem(pNewRun);
 357     ME_ReleaseStyle(style);
 358     return;
 359   } else {
 360     assert(0);
 361   }
 362 }
 363
 364 BOOL ME_ArrowLeft(ME_TextEditor *editor, ME_Cursor *p)
 365 {
 366   if (p->nOffset) {
 367     p->nOffset = ME_StrRelPos2(p->pRun->member.run.strText, p->nOffset, -1);
 368     return TRUE;
 369   }
 370   else
 371   {
 372     ME_DisplayItem *pRun = ME_FindItemBack(p->pRun, diRunOrParagraph);
 373     assert(pRun);
 374     if (pRun->type == diRun) {
 375       p->pRun = pRun;
 376       assert(p->pRun->type == diRun);
 377       assert(pRun->member.run.strText->nLen);
 378       p->nOffset = pRun->member.run.strText->nLen;
 379       if (p->nOffset) {
 380         p->nOffset = ME_StrRelPos2(pRun->member.run.strText, p->nOffset, -1);
 381         return TRUE;
 382       }
 383       else
 384         assert(0);
 385     }
 386     if (pRun->type == diParagraph)
 387     {
 388       if (pRun->member.para.prev_para->type == diTextStart)
 389         return FALSE;
 390       assert(pRun->member.para.prev_para->type == diParagraph);
 391       pRun = ME_FindItemBack(pRun, diRunOrParagraph);
 392       /* every paragraph ought to have at least one run */
 393       assert(pRun && pRun->type == diRun);
 394       assert(pRun->member.run.nFlags & MERF_ENDPARA);
 395       p->pRun = pRun;
 396       p->nOffset = 0;
 397       return TRUE;
 398     }
 399     assert(0);
 400   }
 401   return FALSE;
 402 }
 403
 404 BOOL ME_ArrowRight(ME_TextEditor *editor, ME_Cursor *p)
 405 {
 406   int new_ofs = ME_StrRelPos2(p->pRun->member.run.strText, p->nOffset, 1);
 407   if (new_ofs<p->pRun->member.run.strText->nLen) {
 408     p->nOffset = new_ofs;
 409   }
 410   else
 411   {
 412     ME_DisplayItem *pRun = ME_FindItemFwd(p->pRun, diRun);
 413     if (pRun) {
 414       p->pRun = pRun;
 415       assert(p->pRun->type == diRun);
 416       p->nOffset = 0;
 417     }
 418   }
 419   return TRUE;
 420 }
 421
 422 int ME_GetCursorOfs(ME_TextEditor *editor, int nCursor)
 423 {
 424   ME_Cursor *pCursor = &editor->pCursors[nCursor];
 425
 426   return ME_GetParagraph(pCursor->pRun)->member.para.nCharOfs
 427     + pCursor->pRun->member.run.nCharOfs + pCursor->nOffset;
 428 }
 429
 430 int ME_FindPixelPos(ME_TextEditor *editor, int x, int y, ME_Cursor *result, BOOL *is_eol)
 431 {
 432   ME_DisplayItem *p = editor->pBuffer->pFirst->member.para.next_para;
 433   int rx = 0;
 434
 435   if (is_eol)
 436     *is_eol = 0;
 437
 438   while(p != editor->pBuffer->pLast)
 439   {
 440     if (p->type == diParagraph)
 441     {
 442       int ry = y - p->member.para.nYPos;
 443       if (ry < 0)
 444       {
 445         result->pRun = ME_FindItemFwd(p, diRun);
 446         result->nOffset = 0;
 447         return 0;
 448       }
 449       if (ry >= p->member.para.nHeight)
 450       {
 451         p = p->member.para.next_para;
 452         continue;
 453       }
 454       p = ME_FindItemFwd(p, diStartRow);
 455       y = ry;
 456       continue;
 457     }
 458     if (p->type == diStartRow)
 459     {
 460       int ry = y - p->member.row.nYPos;
 461       if (ry < 0)
 462         return 0;
 463       if (ry >= p->member.row.nHeight)
 464       {
 465         p = ME_FindItemFwd(p, diStartRowOrParagraphOrEnd);
 466         if (p->type != diStartRow)
 467           return 0;
 468         continue;
 469       }
 470       p = ME_FindItemFwd(p, diRun);
 471       continue;
 472     }
 473     if (p->type == diRun)
 474     {
 475       ME_DisplayItem *pp;
 476       rx = x - p->member.run.pt.x;
 477       if (rx < 0)
 478         rx = 0;
 479       if (rx >= p->member.run.nWidth) /* not this run yet... find next item */
 480       {
 481         pp = p;
 482         do {
 483           p = p->next;
 484           if (p->type == diRun)
 485           {
 486             rx = x - p->member.run.pt.x;
 487             goto continue_search;
 488           }
 489           if (p->type == diStartRow)
 490           {
 491             p = ME_FindItemFwd(p, diRun);
 492             if (is_eol)
 493               *is_eol = 1;
 494             rx = 0; /* FIXME not sure */
 495             goto found_here;
 496           }
 497           if (p->type == diParagraph || p->type == diTextEnd)
 498           {
 499             rx = 0; /* FIXME not sure */
 500             p = pp;
 501             goto found_here;
 502           }
 503         } while(1);
 504         continue;
 505       }
 506     found_here:
 507       if (p->member.run.nFlags & MERF_ENDPARA)
 508         rx = 0;
 509       result->pRun = p;
 510       result->nOffset = ME_CharFromPointCursor(editor, rx, &p->member.run);
 511       if (editor->pCursors[0].nOffset == p->member.run.strText->nLen && rx)
 512       {
 513         result->pRun = ME_FindItemFwd(editor->pCursors[0].pRun, diRun);
 514         result->nOffset = 0;
 515       }
 516       return 1;
 517     }
 518     assert(0);
 519   continue_search:
 520     ;
 521   }
 522   result->pRun = ME_FindItemBack(p, diRun);
 523   result->nOffset = 0;
 524   assert(result->pRun->member.run.nFlags & MERF_ENDPARA);
 525   return 0;
 526 }
 527
 528 void ME_LButtonDown(ME_TextEditor *editor, int x, int y)
 529 {
 530   ME_Cursor tmp_cursor;
 531   int is_selection = 0;
 532
 533   editor->nUDArrowX = -1;
 534
 535   y += ME_GetYScrollPos(editor);
 536
 537   tmp_cursor = editor->pCursors[0];
 538   is_selection = ME_IsSelection(editor);
 539
 540   ME_FindPixelPos(editor, x, y, &editor->pCursors[0], &editor->bCaretAtEnd);
 541
 542   if (GetKeyState(VK_SHIFT)>=0)
 543   {
 544     editor->pCursors[1] = editor->pCursors[0];
 545   }
 546   else
 547   {
 548     if (!is_selection) {
 549       editor->pCursors[1] = tmp_cursor;
 550       is_selection = 1;
 551     }
 552   }
 553   HideCaret(editor->hWnd);
 554   ME_MoveCaret(editor);
 555   if (is_selection)
 556     ME_Repaint(editor);
 557   ShowCaret(editor->hWnd);
 558   ME_ClearTempStyle(editor);
 559   ME_SendSelChange(editor);
 560 }
 561
 562 void ME_MouseMove(ME_TextEditor *editor, int x, int y)
 563 {
 564   ME_Cursor tmp_cursor;
 565
 566   y += ME_GetYScrollPos(editor);
 567
 568   tmp_cursor = editor->pCursors[0];
 569   if (!ME_FindPixelPos(editor, x, y, &editor->pCursors[0], &editor->bCaretAtEnd))
 570     /* return */;
 571
 572   if (tmp_cursor.pRun == editor->pCursors[0].pRun &&
 573       tmp_cursor.nOffset == editor->pCursors[0].nOffset)
 574     return;
 575
 576   HideCaret(editor->hWnd);
 577   ME_MoveCaret(editor);
 578   ME_Repaint(editor);
 579   ShowCaret(editor->hWnd);
 580   ME_SendSelChange(editor);
 581 }
 582
 583 static ME_DisplayItem *ME_FindRunInRow(ME_TextEditor *editor, ME_DisplayItem *pRow,
 584                                 int x, int *pOffset, int *pbCaretAtEnd)
 585 {
 586   ME_DisplayItem *pNext, *pLastRun;
 587   pNext = ME_FindItemFwd(pRow, diRunOrStartRow);
 588   assert(pNext->type == diRun);
 589   pLastRun = pNext;
 590   *pbCaretAtEnd = FALSE;
 591   do {
 592     int run_x = pNext->member.run.pt.x;
 593     int width = pNext->member.run.nWidth;
 594     if (x < run_x)
 595     {
 596       if (pOffset) *pOffset = 0;
 597       return pNext;
 598     }
 599     if (x >= run_x && x < run_x+width)
 600     {
 601       int ch = ME_CharFromPointCursor(editor, x-run_x, &pNext->member.run);
 602       ME_String *s = pNext->member.run.strText;
 603       if (ch < s->nLen) {
 604         if (pOffset)
 605           *pOffset = ch;
 606         return pNext;
 607       }
 608     }
 609     pLastRun = pNext;
 610     pNext = ME_FindItemFwd(pNext, diRunOrStartRow);
 611   } while(pNext && pNext->type == diRun);
 612
 613   if ((pLastRun->member.run.nFlags & MERF_ENDPARA) == 0)
 614   {
 615     pNext = ME_FindItemFwd(pNext, diRun);
 616     if (pbCaretAtEnd) *pbCaretAtEnd = 1;
 617     if (pOffset) *pOffset = 0;
 618     return pNext;
 619   } else {
 620     if (pbCaretAtEnd) *pbCaretAtEnd = 0;
 621     if (pOffset) *pOffset = 0;
 622     return pLastRun;
 623   }
 624 }
 625
 626 static int ME_GetXForArrow(ME_TextEditor *editor, ME_Cursor *pCursor)
 627 {
 628   ME_DisplayItem *pRun = pCursor->pRun;
 629   int x;
 630
 631   if (editor->nUDArrowX != -1)
 632     x = editor->nUDArrowX;
 633   else {
 634     if (editor->bCaretAtEnd)
 635     {
 636       pRun = ME_FindItemBack(pRun, diRun);
 637       assert(pRun);
 638       x = pRun->member.run.pt.x + pRun->member.run.nWidth;
 639     }
 640     else {
 641       x = pRun->member.run.pt.x;
 642       x += ME_PointFromChar(editor, &pRun->member.run, pCursor->nOffset);
 643     }
 644     editor->nUDArrowX = x;
 645   }
 646   return x;
 647 }
 648
 649 void ME_ArrowUp(ME_TextEditor *editor, ME_Cursor *pCursor)
 650 {
 651   ME_DisplayItem *pRun = pCursor->pRun;
 652   ME_DisplayItem *pItem, *pItem2;
 653   int x = ME_GetXForArrow(editor, pCursor);
 654
 655   if (editor->bCaretAtEnd && !pCursor->nOffset)
 656   {
 657     pRun = ME_FindItemBack(pRun, diRun);
 658     if (!pRun)
 659       return;
 660   }
 661
 662   /* start of this row */
 663   pItem = ME_FindItemBack(pRun, diStartRow);
 664   assert(pItem);
 665   /* start of the previous row */
 666   pItem2 = ME_FindItemBack(pItem, diStartRow);
 667   /* no previous row = the first line of the first paragraph */
 668   if (!pItem2) /* can't go up - don't go BOL (as in MS richedit) */
 669     return;
 670   /* FIXME
 671   ME_WrapTextParagraph(editor, ME_FindItemBack(pItem2, diParagraph));
 672   */
 673   pCursor->pRun = ME_FindRunInRow(editor, pItem2, x, &pCursor->nOffset, &editor->bCaretAtEnd);
 674 }
 675
 676 void ME_ArrowDown(ME_TextEditor *editor, ME_Cursor *pCursor)
 677 {
 678   ME_DisplayItem *pRun = pCursor->pRun;
 679   ME_DisplayItem *pItem;
 680   int x = ME_GetXForArrow(editor, pCursor);
 681   if (!pCursor->nOffset && editor->bCaretAtEnd)
 682   {
 683     pRun = ME_FindItemBack(pRun, diRun);
 684 /*    x = pRun->member.run.pt.x + pRun->member.run.nWidth; */
 685   }
 686   /* start of the next row */
 687   pItem = ME_FindItemFwd(pRun, diStartRow);
 688   /* FIXME If diParagraph is before diStartRow, wrap the next paragraph?
 689   */
 690   if (!pItem)
 691   {
 692     /* next row not found - ignore */
 693     return;
 694   }
 695   pCursor->pRun = ME_FindRunInRow(editor, pItem, x, &pCursor->nOffset, &editor->bCaretAtEnd);
 696   assert(pCursor->pRun);
 697   assert(pCursor->pRun->type == diRun);
 698 }
 699
 700 void ME_ArrowPageUp(ME_TextEditor *editor, ME_Cursor *pCursor)
 701 {
 702   ME_DisplayItem *pRun = pCursor->pRun;
 703   ME_DisplayItem *pLast, *p;
 704   int x, y, ys, yd, yp, yprev;
 705   ME_Cursor tmp_curs = *pCursor;
 706
 707   x = ME_GetXForArrow(editor, pCursor);
 708   if (!pCursor->nOffset && editor->bCaretAtEnd)
 709     pRun = ME_FindItemBack(pRun, diRun);
 710
 711   p = ME_FindItemBack(pRun, diStartRowOrParagraph);
 712   assert(p->type == diStartRow);
 713   yp = ME_FindItemBack(p, diParagraph)->member.para.nYPos;
 714   yprev = ys = y = yp + p->member.row.nYPos;
 715   yd = y - editor->sizeWindow.cy;
 716   pLast = p;
 717
 718   do {
 719     p = ME_FindItemBack(p, diStartRowOrParagraph);
 720     if (!p)
 721       break;
 722     if (p->type == diParagraph) { /* crossing paragraphs */
 723       if (p->member.para.prev_para == NULL)
 724         break;
 725       yp = p->member.para.prev_para->member.para.nYPos;
 726       continue;
 727     }
 728     y = yp + p->member.row.nYPos;
 729     if (y < yd)
 730       break;
 731     pLast = p;
 732     yprev = y;
 733   } while(1);
 734
 735   pCursor->pRun = ME_FindRunInRow(editor, pLast, x, &pCursor->nOffset, &editor->bCaretAtEnd);
 736   ME_UpdateSelection(editor, &tmp_curs);
 737   if (yprev < editor->sizeWindow.cy)
 738   {
 739     ME_EnsureVisible(editor, ME_FindItemFwd(editor->pBuffer->pFirst, diRun));
 740     ME_Repaint(editor);
 741   }
 742   else {
 743     ME_Scroll(editor, 0, ys-yprev);
 744     ME_Repaint(editor);
 745   }
 746   assert(pCursor->pRun);
 747   assert(pCursor->pRun->type == diRun);
 748 }
 749
 750 /* FIXME: in the original RICHEDIT, PageDown always scrolls by the same amount
 751    of pixels, even if it makes the scroll bar position exceed its normal maximum.
 752    In such a situation, clicking the scrollbar restores its position back to the
 753    normal range (ie. sets it to (doclength-screenheight)). */
 754
 755 void ME_ArrowPageDown(ME_TextEditor *editor, ME_Cursor *pCursor)
 756 {
 757   ME_DisplayItem *pRun = pCursor->pRun;
 758   ME_DisplayItem *pLast, *p;
 759   int x, y, ys, yd, yp, yprev;
 760   ME_Cursor tmp_curs = *pCursor;
 761
 762   x = ME_GetXForArrow(editor, pCursor);
 763   if (!pCursor->nOffset && editor->bCaretAtEnd)
 764     pRun = ME_FindItemBack(pRun, diRun);
 765
 766   p = ME_FindItemBack(pRun, diStartRowOrParagraph);
 767   assert(p->type == diStartRow);
 768   yp = ME_FindItemBack(p, diParagraph)->member.para.nYPos;
 769   yprev = ys = y = yp + p->member.row.nYPos;
 770   yd = y + editor->sizeWindow.cy;
 771   pLast = p;
 772
 773   do {
 774     p = ME_FindItemFwd(p, diStartRowOrParagraph);
 775     if (!p)
 776       break;
 777     if (p->type == diParagraph) {
 778       yp = p->member.para.nYPos;
 779       continue;
 780     }
 781     y = yp + p->member.row.nYPos;
 782     if (y >= yd)
 783       break;
 784     pLast = p;
 785     yprev = y;
 786   } while(1);
 787
 788   pCursor->pRun = ME_FindRunInRow(editor, pLast, x, &pCursor->nOffset, &editor->bCaretAtEnd);
 789   ME_UpdateSelection(editor, &tmp_curs);
 790   if (yprev >= editor->nTotalLength-editor->sizeWindow.cy)
 791   {
 792     ME_EnsureVisible(editor, ME_FindItemBack(editor->pBuffer->pLast, diRun));
 793     ME_Repaint(editor);
 794   }
 795   else {
 796     ME_Scroll(editor, 0, ys-yprev);
 797     ME_Repaint(editor);
 798   }
 799   assert(pCursor->pRun);
 800   assert(pCursor->pRun->type == diRun);
 801 }
 802
 803 void ME_ArrowHome(ME_TextEditor *editor, ME_Cursor *pCursor)
 804 {
 805   ME_DisplayItem *pRow = ME_FindItemBack(pCursor->pRun, diStartRow);
 806   if (pRow) {
 807     ME_DisplayItem *pRun;
 808     if (editor->bCaretAtEnd && !pCursor->nOffset) {
 809       pRow = ME_FindItemBack(pRow, diStartRow);
 810       if (!pRow)
 811         return;
 812     }
 813     pRun = ME_FindItemFwd(pRow, diRun);
 814     if (pRun) {
 815       pCursor->pRun = pRun;
 816       pCursor->nOffset = 0;
 817     }
 818   }
 819   editor->bCaretAtEnd = FALSE;
 820 }
 821
 822 void ME_ArrowCtrlHome(ME_TextEditor *editor, ME_Cursor *pCursor)
 823 {
 824   ME_DisplayItem *pRow = ME_FindItemBack(pCursor->pRun, diTextStart);
 825   if (pRow) {
 826     ME_DisplayItem *pRun = ME_FindItemFwd(pRow, diRun);
 827     if (pRun) {
 828       pCursor->pRun = pRun;
 829       pCursor->nOffset = 0;
 830     }
 831   }
 832 }
 833
 834 void ME_ArrowEnd(ME_TextEditor *editor, ME_Cursor *pCursor)
 835 {
 836   ME_DisplayItem *pRow;
 837
 838   if (editor->bCaretAtEnd && !pCursor->nOffset)
 839     return;
 840
 841   pRow = ME_FindItemFwd(pCursor->pRun, diStartRowOrParagraphOrEnd);
 842   assert(pRow);
 843   if (pRow->type == diStartRow) {
 844     /* FIXME WTF was I thinking about here ? */
 845     ME_DisplayItem *pRun = ME_FindItemFwd(pRow, diRun);
 846     assert(pRun);
 847     pCursor->pRun = pRun;
 848     pCursor->nOffset = 0;
 849     editor->bCaretAtEnd = 1;
 850     return;
 851   }
 852   pCursor->pRun = ME_FindItemBack(pRow, diRun);
 853   assert(pCursor->pRun && pCursor->pRun->member.run.nFlags & MERF_ENDPARA);
 854   pCursor->nOffset = 0;
 855   editor->bCaretAtEnd = FALSE;
 856 }
 857
 858 void ME_ArrowCtrlEnd(ME_TextEditor *editor, ME_Cursor *pCursor)
 859 {
 860   ME_DisplayItem *p = ME_FindItemFwd(pCursor->pRun, diTextEnd);
 861   assert(p);
 862   p = ME_FindItemBack(p, diRun);
 863   assert(p);
 864   assert(p->member.run.nFlags & MERF_ENDPARA);
 865   pCursor->pRun = p;
 866   pCursor->nOffset = 0;
 867   editor->bCaretAtEnd = FALSE;
 868 }
 869
 870 BOOL ME_IsSelection(ME_TextEditor *editor)
 871 {
 872   return memcmp(&editor->pCursors[0], &editor->pCursors[1], sizeof(ME_Cursor))!=0;
 873 }
 874
 875 int ME_GetSelCursor(ME_TextEditor *editor, int dir)
 876 {
 877   int cdir = ME_GetCursorOfs(editor, 0) - ME_GetCursorOfs(editor, 1);
 878
 879   if (cdir*dir>0)
 880     return 0;
 881   else
 882     return 1;
 883 }
 884
 885 BOOL ME_CancelSelection(ME_TextEditor *editor, int dir)
 886 {
 887   int cdir;
 888
 889   if (GetKeyState(VK_SHIFT)<0)
 890     return FALSE;
 891   if (!memcmp(&editor->pCursors[0], &editor->pCursors[1], sizeof(ME_Cursor)))
 892     return FALSE;
 893
 894   cdir = ME_GetCursorOfs(editor, 0) - ME_GetCursorOfs(editor, 1);
 895
 896   if (cdir*dir>0)
 897     editor->pCursors[1] = editor->pCursors[0];
 898   else
 899     editor->pCursors[0] = editor->pCursors[1];
 900   ME_Repaint(editor);
 901   return TRUE;
 902 }
 903
 904 BOOL ME_UpdateSelection(ME_TextEditor *editor, ME_Cursor *pTempCursor)
 905 {
 906   ME_Cursor old_anchor = editor->pCursors[1];
 907
 908   if (GetKeyState(VK_SHIFT)>=0) /* cancelling selection */
 909   {
 910     /* any selection was present ? if so, it's no more, repaint ! */
 911     editor->pCursors[1] = editor->pCursors[0];
 912     if (memcmp(pTempCursor, &old_anchor, sizeof(ME_Cursor))) {
 913       return TRUE;
 914     }
 915     return FALSE;
 916   }
 917   else
 918   {
 919     if (!memcmp(pTempCursor, &editor->pCursors[1], sizeof(ME_Cursor))) /* starting selection */
 920     {
 921       editor->pCursors[1] = *pTempCursor;
 922       return TRUE;
 923     }
 924   }
 925
 926   ME_Repaint(editor);
 927   return TRUE;
 928 }
 929
 930 void ME_RepaintSelection(ME_TextEditor *editor, ME_Cursor *pTempCursor)
 931 {
 932   if (ME_UpdateSelection(editor, pTempCursor)) {
 933     ME_EnsureVisible(editor, editor->pCursors[0].pRun);
 934     ME_Repaint(editor);
 935   }
 936 }
 937
 938 void ME_DeleteSelection(ME_TextEditor *editor)
 939 {
 940   int from, to;
 941   ME_GetSelection(editor, &from, &to);
 942   ME_DeleteTextAtCursor(editor, ME_GetSelCursor(editor,-1), to-from);
 943 }
 944
 945 ME_Style *ME_GetSelectionInsertStyle(ME_TextEditor *editor)
 946 {
 947   ME_Style *style;
 948   int from, to;
 949   ME_Cursor c;
 950
 951   ME_GetSelection(editor, &from, &to);
 952   ME_CursorFromCharOfs(editor, from, &c);
 953   if (from != to) {
 954     style = c.pRun->member.run.style;
 955     ME_AddRefStyle(style); /* ME_GetInsertStyle has already done that */
 956   }
 957   else
 958     style = ME_GetInsertStyle(editor, 0);
 959   return style;
 960 }
 961
 962 void ME_SendSelChange(ME_TextEditor *editor)
 963 {
 964   SELCHANGE sc;
 965   if (!(editor->nEventMask & ENM_SELCHANGE))
 966     return;
 967   sc.nmhdr.hwndFrom = editor->hWnd;
 968   sc.nmhdr.idFrom = GetWindowLongW(editor->hWnd, GWLP_ID);
 969   sc.nmhdr.code = EN_SELCHANGE;
 970   SendMessageW(editor->hWnd, EM_EXGETSEL, 0, (LPARAM)&sc.chrg);
 971   sc.seltyp = SEL_EMPTY;
 972   if (sc.chrg.cpMin != sc.chrg.cpMax)
 973     sc.seltyp |= SEL_TEXT;
 974   if (sc.chrg.cpMin < sc.chrg.cpMax+1) /* wth were RICHEDIT authors thinking ? */
 975     sc.seltyp |= SEL_MULTICHAR;
 976   SendMessageW(GetParent(editor->hWnd), WM_NOTIFY, sc.nmhdr.idFrom, (LPARAM)&sc);
 977 }
 978
 979 BOOL ME_ArrowKey(ME_TextEditor *editor, int nVKey, int nCtrl)
 980 {
 981   int nCursor = 0;
 982   ME_Cursor *p = &editor->pCursors[nCursor];
 983   ME_Cursor tmp_curs = *p;
 984
 985   switch(nVKey) {
 986     case VK_UP:
 987       ME_ArrowUp(editor, p);
 988       ME_ClearTempStyle(editor);
 989       ME_RepaintSelection(editor, &tmp_curs);
 990       ME_SendSelChange(editor);
 991       return TRUE;
 992     case VK_DOWN:
 993       ME_ArrowDown(editor, p);
 994       ME_ClearTempStyle(editor);
 995       ME_RepaintSelection(editor, &tmp_curs);
 996       ME_SendSelChange(editor);
 997       return TRUE;
 998     case VK_PRIOR:
 999       ME_ArrowPageUp(editor, p);
1000       ME_ClearTempStyle(editor);
1001       ME_SendSelChange(editor);
1002       return TRUE;
1003     case VK_NEXT:
1004       ME_ArrowPageDown(editor, p);
1005       ME_ClearTempStyle(editor);
1006       ME_SendSelChange(editor);
1007       return TRUE;
1008   }
1009
1010   editor->nUDArrowX = -1;
1011   switch(nVKey) {
1012     case VK_BACK: { /* FIXME backspace and delete aren't the same, they act different wrt paragraph style of the merged paragraph */
1013       if (GetWindowLongW(editor->hWnd, GWL_STYLE) & ES_READONLY)
1014         return FALSE;
1015       if (ME_IsSelection(editor))
1016       {
1017         editor->bCaretAtEnd = FALSE; /* FIXME or maybe not */
1018         ME_DeleteSelection(editor);
1019         ME_UpdateRepaint(editor);
1020         return TRUE;
1021       }
1022       if (ME_ArrowLeft(editor, p)) {
1023         editor->bCaretAtEnd = FALSE; /* FIXME or maybe not */
1024         ME_ClearTempStyle(editor);
1025         ME_MoveCaret(editor);
1026         ME_DeleteTextAtCursor(editor, nCursor, 1);
1027         ME_UpdateRepaint(editor);
1028       }
1029       return TRUE;
1030     }
1031     case VK_DELETE: {
1032       if (GetWindowLongW(editor->hWnd, GWL_STYLE) & ES_READONLY)
1033         return FALSE;
1034       /* editor->bCaretAtEnd = 0; FIXME or maybe not */
1035       if (ME_IsSelection(editor))
1036       {
1037         ME_DeleteSelection(editor);
1038         ME_ClearTempStyle(editor);
1039         ME_UpdateRepaint(editor);
1040         return TRUE;
1041       }
1042       ME_DeleteTextAtCursor(editor, nCursor, 1);
1043       ME_ClearTempStyle(editor);
1044       ME_UpdateRepaint(editor);
1045       return TRUE;
1046     }
1047     case VK_HOME: {
1048       if (GetKeyState(VK_CONTROL)<0)
1049         ME_ArrowCtrlHome(editor, p);
1050       else
1051         ME_ArrowHome(editor, p);
1052       editor->bCaretAtEnd = 0;
1053       ME_ClearTempStyle(editor);
1054       ME_RepaintSelection(editor, &tmp_curs);
1055       ME_SendSelChange(editor);
1056       return TRUE;
1057     }
1058     case VK_END:
1059       if (GetKeyState(VK_CONTROL)<0)
1060         ME_ArrowCtrlEnd(editor, p);
1061       else
1062         ME_ArrowEnd(editor, p);
1063       ME_ClearTempStyle(editor);
1064       ME_RepaintSelection(editor, &tmp_curs);
1065       ME_SendSelChange(editor);
1066       return TRUE;
1067     case VK_LEFT:
1068       editor->bCaretAtEnd = 0;
1069       if (ME_CancelSelection(editor, -1))
1070         return TRUE;
1071       ME_ArrowLeft(editor, p);
1072       ME_RepaintSelection(editor, &tmp_curs);
1073       ME_ClearTempStyle(editor);
1074       ME_SendSelChange(editor);
1075       return TRUE;
1076     case VK_RIGHT:
1077       editor->bCaretAtEnd = 0;
1078       if (ME_CancelSelection(editor, +1))
1079         return TRUE;
1080       ME_ArrowRight(editor, p);
1081       ME_RepaintSelection(editor, &tmp_curs);
1082       ME_ClearTempStyle(editor);
1083       ME_SendSelChange(editor);
1084       return TRUE;
1085   }
1086   return FALSE;
1087 }