ReactOS 0.4.16-dev-329-g9223134
Classes | Macros | Typedefs | Enumerations | Functions
edit.c File Reference
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "imm.h"
#include "usp10.h"
#include "commctrl.h"
#include "uxtheme.h"
#include "vsstyle.h"
#include "wine/debug.h"
#include "wine/heap.h"
Include dependency graph for edit.c:

Go to the source code of this file.

Classes

struct  tagLINEDEF
 
struct  EDITSTATE
 
struct  char_width_info
 

Macros

#define BUFLIMIT_INITIAL   30000 /* initial buffer size */
 
#define GROWLENGTH   32 /* buffers granularity in bytes: must be power of 2 */
 
#define ROUND_TO_GROW(size)   (((size) + (GROWLENGTH - 1)) & ~(GROWLENGTH - 1))
 
#define HSCROLL_FRACTION   3 /* scroll window by 1/3 width */
 
#define EF_MODIFIED   0x0001 /* text has been modified */
 
#define EF_FOCUSED   0x0002 /* we have input focus */
 
#define EF_UPDATE   0x0004 /* notify parent of changed state */
 
#define EF_VSCROLL_TRACK   0x0008 /* don't SetScrollPos() since we are tracking the thumb */
 
#define EF_HSCROLL_TRACK   0x0010 /* don't SetScrollPos() since we are tracking the thumb */
 
#define EF_AFTER_WRAP
 
#define EF_USE_SOFTBRK   0x0100 /* Enable soft breaks in text. */
 
#define EF_DIALOGMODE   0x0200 /* Indicates that we are inside a dialog window */
 
#define ID_CB_LISTBOX   1000
 
#define SWAP_UINT32(x, y)   do { UINT temp = (UINT)(x); (x) = (UINT)(y); (y) = temp; } while(0)
 
#define ORDER_UINT(x, y)   do { if ((UINT)(y) < (UINT)(x)) SWAP_UINT32((x),(y)); } while(0)
 

Typedefs

typedef struct tagLINEDEF LINEDEF
 

Enumerations

enum  LINE_END {
  END_0 = 0 , END_WRAP , END_HARD , END_SOFT ,
  END_RICH , END_0 = 0 , END_WRAP , END_HARD ,
  END_SOFT , END_RICH
}
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (edit)
 
static BOOL notify_parent (const EDITSTATE *es, INT code)
 
static LRESULT EDIT_EM_PosFromChar (EDITSTATE *es, INT index, BOOL after_wrap)
 
static BOOL EDIT_EM_CanUndo (const EDITSTATE *es)
 
static void EDIT_EM_EmptyUndoBuffer (EDITSTATE *es)
 
static HBRUSH EDIT_NotifyCtlColor (EDITSTATE *es, HDC hdc)
 
static UINT get_text_length (EDITSTATE *es)
 
static INT EDIT_WordBreakProc (EDITSTATE *es, LPWSTR s, INT index, INT count, INT action)
 
static INT EDIT_CallWordBreakProc (EDITSTATE *es, INT start, INT index, INT count, INT action)
 
static void EDIT_InvalidateUniscribeData_linedef (LINEDEF *line_def)
 
static void EDIT_InvalidateUniscribeData (EDITSTATE *es)
 
static SCRIPT_STRING_ANALYSIS EDIT_UpdateUniscribeData_linedef (EDITSTATE *es, HDC dc, LINEDEF *line_def)
 
static SCRIPT_STRING_ANALYSIS EDIT_UpdateUniscribeData (EDITSTATE *es, HDC dc, INT line)
 
static INT get_vertical_line_count (EDITSTATE *es)
 
static void EDIT_BuildLineDefs_ML (EDITSTATE *es, INT istart, INT iend, INT delta, HRGN hrgn)
 
static void EDIT_CalcLineWidth_SL (EDITSTATE *es)
 
static INT EDIT_CharFromPos (EDITSTATE *es, INT x, INT y, LPBOOL after_wrap)
 
static void EDIT_ConfinePoint (const EDITSTATE *es, LPINT x, LPINT y)
 
static INT EDIT_EM_LineFromChar (EDITSTATE *es, INT index)
 
static INT EDIT_EM_LineIndex (const EDITSTATE *es, INT line)
 
static INT EDIT_EM_LineLength (EDITSTATE *es, INT index)
 
static void EDIT_GetLineRect (EDITSTATE *es, INT line, INT scol, INT ecol, LPRECT rc)
 
static void text_buffer_changed (EDITSTATE *es)
 
static void EDIT_LockBuffer (EDITSTATE *es)
 
static void EDIT_UnlockBuffer (EDITSTATE *es, BOOL force)
 
static BOOL EDIT_MakeFit (EDITSTATE *es, UINT size)
 
static BOOL EDIT_MakeUndoFit (EDITSTATE *es, UINT size)
 
static void EDIT_UpdateTextRegion (EDITSTATE *es, HRGN hrgn, BOOL bErase)
 
static void EDIT_UpdateText (EDITSTATE *es, const RECT *rc, BOOL bErase)
 
static void EDIT_SL_InvalidateText (EDITSTATE *es, INT start, INT end)
 
static void EDIT_ML_InvalidateText (EDITSTATE *es, INT start, INT end)
 
static void EDIT_InvalidateText (EDITSTATE *es, INT start, INT end)
 
static BOOL EDIT_EM_SetSel (EDITSTATE *es, UINT start, UINT end, BOOL after_wrap)
 
static void EDIT_UpdateScrollInfo (EDITSTATE *es)
 
static BOOL EDIT_EM_LineScroll_internal (EDITSTATE *es, INT dx, INT dy)
 
static BOOL EDIT_EM_LineScroll (EDITSTATE *es, INT dx, INT dy)
 
static LRESULT EDIT_EM_Scroll (EDITSTATE *es, INT action)
 
static void EDIT_SetCaretPos (EDITSTATE *es, INT pos, BOOL after_wrap)
 
static void EDIT_EM_ScrollCaret (EDITSTATE *es)
 
static void EDIT_MoveBackward (EDITSTATE *es, BOOL extend)
 
static void EDIT_MoveDown_ML (EDITSTATE *es, BOOL extend)
 
static void EDIT_MoveEnd (EDITSTATE *es, BOOL extend, BOOL ctrl)
 
static void EDIT_MoveForward (EDITSTATE *es, BOOL extend)
 
static void EDIT_MoveHome (EDITSTATE *es, BOOL extend, BOOL ctrl)
 
static void EDIT_MovePageDown_ML (EDITSTATE *es, BOOL extend)
 
static void EDIT_MovePageUp_ML (EDITSTATE *es, BOOL extend)
 
static void EDIT_MoveUp_ML (EDITSTATE *es, BOOL extend)
 
static void EDIT_MoveWordBackward (EDITSTATE *es, BOOL extend)
 
static void EDIT_MoveWordForward (EDITSTATE *es, BOOL extend)
 
static INT EDIT_PaintText (EDITSTATE *es, HDC dc, INT x, INT y, INT line, INT col, INT count, BOOL rev)
 
static void EDIT_PaintLine (EDITSTATE *es, HDC dc, INT line, BOOL rev)
 
static void EDIT_AdjustFormatRect (EDITSTATE *es)
 
static void EDIT_SetRectNP (EDITSTATE *es, const RECT *rc)
 
static LRESULT EDIT_EM_CharFromPos (EDITSTATE *es, INT x, INT y)
 
static BOOL EDIT_EM_FmtLines (EDITSTATE *es, BOOL add_eol)
 
static HLOCAL EDIT_EM_GetHandle (EDITSTATE *es)
 
static INT EDIT_EM_GetLine (EDITSTATE *es, INT line, LPWSTR dst)
 
static LRESULT EDIT_EM_GetSel (const EDITSTATE *es, PUINT start, PUINT end)
 
static void EDIT_EM_ReplaceSel (EDITSTATE *es, BOOL can_undo, const WCHAR *lpsz_replace, UINT strl, BOOL send_update, BOOL honor_limit)
 
static void EDIT_EM_SetHandle (EDITSTATE *es, HLOCAL hloc)
 
static void EDIT_EM_SetLimitText (EDITSTATE *es, UINT limit)
 
static BOOL is_cjk (HDC dc)
 
static int get_cjk_fontinfo_margin (int width, int side_bearing)
 
BOOL WINAPI GetCharWidthInfo (HDC, struct char_width_info *)
 
static void EDIT_EM_SetMargins (EDITSTATE *es, INT action, WORD left, WORD right, BOOL repaint)
 
static void EDIT_EM_SetPasswordChar (EDITSTATE *es, WCHAR c)
 
static BOOL EDIT_EM_SetTabStops (EDITSTATE *es, INT count, const INT *tabs)
 
static void EDIT_EM_SetWordBreakProc (EDITSTATE *es, EDITWORDBREAKPROCW wbp)
 
static BOOL EDIT_EM_Undo (EDITSTATE *es)
 
static BOOL EDIT_IsInsideDialog (EDITSTATE *es)
 
static void EDIT_WM_Paste (EDITSTATE *es)
 
static void EDIT_WM_Copy (EDITSTATE *es)
 
static void EDIT_WM_Clear (EDITSTATE *es)
 
static void EDIT_WM_Cut (EDITSTATE *es)
 
static LRESULT EDIT_WM_Char (EDITSTATE *es, WCHAR c)
 
static void EDIT_ContextMenuCommand (EDITSTATE *es, UINT id)
 
static void EDIT_WM_ContextMenu (EDITSTATE *es, INT x, INT y)
 
static INT EDIT_WM_GetText (const EDITSTATE *es, INT count, LPWSTR dst)
 
static BOOL EDIT_CheckCombo (EDITSTATE *es, UINT msg, INT key)
 
static LRESULT EDIT_WM_KeyDown (EDITSTATE *es, INT key)
 
static LRESULT EDIT_WM_KillFocus (HTHEME theme, EDITSTATE *es)
 
static LRESULT EDIT_WM_LButtonDblClk (EDITSTATE *es)
 
static LRESULT EDIT_WM_LButtonDown (EDITSTATE *es, DWORD keys, INT x, INT y)
 
static LRESULT EDIT_WM_LButtonUp (EDITSTATE *es)
 
static LRESULT EDIT_WM_MButtonDown (EDITSTATE *es)
 
static LRESULT EDIT_WM_MouseMove (EDITSTATE *es, INT x, INT y)
 
static void EDIT_WM_Paint (EDITSTATE *es, HDC hdc)
 
static void EDIT_WM_NCPaint (HWND hwnd, HRGN region)
 
static void EDIT_WM_SetFocus (HTHEME theme, EDITSTATE *es)
 
static DWORD get_font_margins (HDC hdc, const TEXTMETRICW *tm)
 
static void EDIT_WM_SetFont (EDITSTATE *es, HFONT font, BOOL redraw)
 
static void EDIT_WM_SetText (EDITSTATE *es, LPCWSTR text)
 
static void EDIT_WM_Size (EDITSTATE *es, UINT action)
 
static LRESULT EDIT_WM_StyleChanged (EDITSTATE *es, WPARAM which, const STYLESTRUCT *style)
 
static LRESULT EDIT_WM_SysKeyDown (EDITSTATE *es, INT key, DWORD key_data)
 
static void EDIT_WM_Timer (EDITSTATE *es)
 
static LRESULT EDIT_WM_HScroll (EDITSTATE *es, INT action, INT pos)
 
static LRESULT EDIT_WM_VScroll (EDITSTATE *es, INT action, INT pos)
 
static LRESULT EDIT_EM_GetThumb (EDITSTATE *es)
 
static WCHAR * heap_strdupW (const WCHAR *str)
 
static BOOL EDIT_EM_SetCueBanner (EDITSTATE *es, BOOL draw_focused, const WCHAR *cue_text)
 
static BOOL EDIT_EM_GetCueBanner (EDITSTATE *es, WCHAR *buf, DWORD size)
 
static void EDIT_GetCompositionStr (HIMC hIMC, LPARAM CompFlag, EDITSTATE *es)
 
static void EDIT_GetResultStr (HIMC hIMC, EDITSTATE *es)
 
static void EDIT_ImeComposition (HWND hwnd, LPARAM CompFlag, EDITSTATE *es)
 
static LRESULT EDIT_WM_NCCreate (HWND hwnd, LPCREATESTRUCTW lpcs)
 
static LRESULT EDIT_WM_Create (EDITSTATE *es, const WCHAR *name)
 
static LRESULT EDIT_WM_NCDestroy (EDITSTATE *es)
 
static LRESULT CALLBACK EDIT_WindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
void EDIT_Register (void)
 

Macro Definition Documentation

◆ BUFLIMIT_INITIAL

#define BUFLIMIT_INITIAL   30000 /* initial buffer size */

Definition at line 57 of file edit.c.

◆ EF_AFTER_WRAP

#define EF_AFTER_WRAP
Value:
0x0080 /* the caret is displayed after the last character of a
wrapped line, instead of in front of the next character */

Definition at line 70 of file edit.c.

◆ EF_DIALOGMODE

#define EF_DIALOGMODE   0x0200 /* Indicates that we are inside a dialog window */

Definition at line 72 of file edit.c.

◆ EF_FOCUSED

#define EF_FOCUSED   0x0002 /* we have input focus */

Definition at line 66 of file edit.c.

◆ EF_HSCROLL_TRACK

#define EF_HSCROLL_TRACK   0x0010 /* don't SetScrollPos() since we are tracking the thumb */

Definition at line 69 of file edit.c.

◆ EF_MODIFIED

#define EF_MODIFIED   0x0001 /* text has been modified */

Definition at line 65 of file edit.c.

◆ EF_UPDATE

#define EF_UPDATE   0x0004 /* notify parent of changed state */

Definition at line 67 of file edit.c.

◆ EF_USE_SOFTBRK

#define EF_USE_SOFTBRK   0x0100 /* Enable soft breaks in text. */

Definition at line 71 of file edit.c.

◆ EF_VSCROLL_TRACK

#define EF_VSCROLL_TRACK   0x0008 /* don't SetScrollPos() since we are tracking the thumb */

Definition at line 68 of file edit.c.

◆ GROWLENGTH

#define GROWLENGTH   32 /* buffers granularity in bytes: must be power of 2 */

Definition at line 58 of file edit.c.

◆ HSCROLL_FRACTION

#define HSCROLL_FRACTION   3 /* scroll window by 1/3 width */

Definition at line 60 of file edit.c.

◆ ID_CB_LISTBOX

#define ID_CB_LISTBOX   1000

Definition at line 74 of file edit.c.

◆ ORDER_UINT

#define ORDER_UINT (   x,
  y 
)    do { if ((UINT)(y) < (UINT)(x)) SWAP_UINT32((x),(y)); } while(0)

Definition at line 164 of file edit.c.

◆ ROUND_TO_GROW

#define ROUND_TO_GROW (   size)    (((size) + (GROWLENGTH - 1)) & ~(GROWLENGTH - 1))

Definition at line 59 of file edit.c.

◆ SWAP_UINT32

#define SWAP_UINT32 (   x,
  y 
)    do { UINT temp = (UINT)(x); (x) = (UINT)(y); (y) = temp; } while(0)

Definition at line 163 of file edit.c.

Typedef Documentation

◆ LINEDEF

typedef struct tagLINEDEF LINEDEF

Enumeration Type Documentation

◆ LINE_END

enum LINE_END
Enumerator
END_0 
END_WRAP 
END_HARD 
END_SOFT 
END_RICH 
END_0 
END_WRAP 
END_HARD 
END_SOFT 
END_RICH 

Definition at line 76 of file edit.c.

78{
79 END_0 = 0, /* line ends with terminating '\0' character */
80 END_WRAP, /* line is wrapped */
81 END_HARD, /* line ends with a hard return '\r\n' */
82 END_SOFT, /* line ends with a soft return '\r\r\n' */
83 END_RICH /* line ends with a single '\n' */
END_SOFT
@ END_SOFT
Definition: edit.c:81
END_RICH
@ END_RICH
Definition: edit.c:82
END_HARD
@ END_HARD
Definition: edit.c:80
END_0
@ END_0
Definition: edit.c:78
END_WRAP
@ END_WRAP
Definition: edit.c:79

Function Documentation

◆ EDIT_AdjustFormatRect()

static void EDIT_AdjustFormatRect ( EDITSTATE *  es)
static

Definition at line 2268 of file edit.c.

2270{
2271 RECT ClientRect;
2272
2273 es->format_rect.right = max(es->format_rect.right, es->format_rect.left + es->char_width);
2274 if (es->style & ES_MULTILINE)
2275 {
2276 INT fw, vlc, max_x_offset, max_y_offset;
2277
2278 vlc = get_vertical_line_count(es);
2279 es->format_rect.bottom = es->format_rect.top + vlc * es->line_height;
2280
2281 /* correct es->x_offset */
2282 fw = es->format_rect.right - es->format_rect.left;
2283 max_x_offset = es->text_width - fw;
2284 if(max_x_offset < 0) max_x_offset = 0;
2285 if(es->x_offset > max_x_offset)
2286 es->x_offset = max_x_offset;
2287
2288 /* correct es->y_offset */
2289 max_y_offset = es->line_count - vlc;
2290 if(max_y_offset < 0) max_y_offset = 0;
2291 if(es->y_offset > max_y_offset)
2292 es->y_offset = max_y_offset;
2293
2294 /* force scroll info update */
2295 EDIT_UpdateScrollInfo(es);
2296 }
2297 else
2298 /* Windows doesn't care to fix text placement for SL controls */
2299 es->format_rect.bottom = es->format_rect.top + es->line_height;
2300
2301 /* Always stay within the client area */
2302 GetClientRect(es->hwndSelf, &ClientRect);
2303 es->format_rect.bottom = min(es->format_rect.bottom, ClientRect.bottom);
2304
2305 if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL))
2306 EDIT_BuildLineDefs_ML(es, 0, get_text_length(es), 0, NULL);
2307
2308 EDIT_SetCaretPos(es, es->selection_end, es->flags & EF_AFTER_WRAP);
NULL
#define NULL
Definition: types.h:112
get_vertical_line_count
static INT get_vertical_line_count(EDITSTATE *es)
Definition: edit.c:414
EF_AFTER_WRAP
#define EF_AFTER_WRAP
Definition: edit.c:70
EDIT_SetCaretPos
static void EDIT_SetCaretPos(EDITSTATE *es, INT pos, BOOL after_wrap)
Definition: edit.c:1750
EDIT_BuildLineDefs_ML
static void EDIT_BuildLineDefs_ML(EDITSTATE *es, INT istart, INT iend, INT delta, HRGN hrgn)
Definition: edit.c:429
get_text_length
static UINT get_text_length(EDITSTATE *es)
Definition: edit.c:216
EDIT_UpdateScrollInfo
static void EDIT_UpdateScrollInfo(EDITSTATE *es)
Definition: edit.c:1560
es
#define es
Definition: i386-dis.c:440
min
#define min(a, b)
Definition: monoChain.cc:55
ES_AUTOHSCROLL
#define ES_AUTOHSCROLL
Definition: pedump.c:672
ES_MULTILINE
#define ES_MULTILINE
Definition: pedump.c:667
tagRECT::bottom
LONG bottom
Definition: windef.h:309
max
#define max(a, b)
Definition: svc.c:63
INT
int32_t INT
Definition: typedefs.h:58
GetClientRect
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)

Referenced by EDIT_EM_SetMargins(), and EDIT_SetRectNP().

◆ EDIT_BuildLineDefs_ML()

static void EDIT_BuildLineDefs_ML ( EDITSTATE *  es,
INT  istart,
INT  iend,
INT  delta,
HRGN  hrgn 
)
static

Definition at line 429 of file edit.c.

431{
432 LPWSTR current_position, cp;
433 INT fw;
434 LINEDEF *current_line;
435 LINEDEF *previous_line;
436 LINEDEF *start_line;
437 INT line_index = 0, nstart_line, nstart_index;
438 INT line_count = es->line_count;
439 INT orig_net_length;
440 RECT rc;
441 INT vlc;
442
443 if (istart == iend && delta == 0)
444 return;
445
446 previous_line = NULL;
447 current_line = es->first_line_def;
448
449 /* Find starting line. istart must lie inside an existing line or
450 * at the end of buffer */
451 do {
452 if (istart < current_line->index + current_line->length ||
453 current_line->ending == END_0)
454 break;
455
456 previous_line = current_line;
457 current_line = current_line->next;
458 line_index++;
459 } while (current_line);
460
461 if (!current_line) /* Error occurred start is not inside previous buffer */
462 {
463 FIXME(" modification occurred outside buffer\n");
464 return;
465 }
466
467 /* Remember start of modifications in order to calculate update region */
468 nstart_line = line_index;
469 nstart_index = current_line->index;
470
471 /* We must start to reformat from the previous line since the modifications
472 * may have caused the line to wrap upwards. */
473 if (!(es->style & ES_AUTOHSCROLL) && line_index > 0)
474 {
475 line_index--;
476 current_line = previous_line;
477 }
478 start_line = current_line;
479
480 fw = es->format_rect.right - es->format_rect.left;
481 current_position = es->text + current_line->index;
482 vlc = get_vertical_line_count(es);
483 do {
484 if (current_line != start_line)
485 {
486 if (!current_line || current_line->index + delta > current_position - es->text)
487 {
488 /* The buffer has been expanded, create a new line and
489 insert it into the link list */
490 LINEDEF *new_line = heap_alloc_zero(sizeof(*new_line));
491 new_line->next = previous_line->next;
492 previous_line->next = new_line;
493 current_line = new_line;
494 es->line_count++;
495 }
496 else if (current_line->index + delta < current_position - es->text)
497 {
498 /* The previous line merged with this line so we delete this extra entry */
499 previous_line->next = current_line->next;
500 heap_free(current_line);
501 current_line = previous_line->next;
502 es->line_count--;
503 continue;
504 }
505 else /* current_line->index + delta == current_position */
506 {
507 if (current_position - es->text > iend)
508 break; /* We reached end of line modifications */
509 /* else recalculate this line */
510 }
511 }
512
513 current_line->index = current_position - es->text;
514 orig_net_length = current_line->net_length;
515
516 /* Find end of line */
517 cp = current_position;
518 while (*cp) {
519 if (*cp == '\n') break;
520 if ((*cp == '\r') && (*(cp + 1) == '\n'))
521 break;
522 cp++;
523 }
524
525 /* Mark type of line termination */
526 if (!(*cp)) {
527 current_line->ending = END_0;
528 current_line->net_length = lstrlenW(current_position);
529 } else if ((cp > current_position) && (*(cp - 1) == '\r')) {
530 current_line->ending = END_SOFT;
531 current_line->net_length = cp - current_position - 1;
532 } else if (*cp == '\n') {
533 current_line->ending = END_RICH;
534 current_line->net_length = cp - current_position;
535 } else {
536 current_line->ending = END_HARD;
537 current_line->net_length = cp - current_position;
538 }
539
540 if (current_line->net_length)
541 {
542 const SIZE *sz;
543 EDIT_InvalidateUniscribeData_linedef(current_line);
544 EDIT_UpdateUniscribeData_linedef(es, NULL, current_line);
545 if (current_line->ssa)
546 {
547 sz = ScriptString_pSize(current_line->ssa);
548 /* Calculate line width */
549 current_line->width = sz->cx;
550 }
551 else current_line->width = es->char_width * current_line->net_length;
552 }
553 else current_line->width = 0;
554
555 /* FIXME: check here for lines that are too wide even in AUTOHSCROLL (> 32767 ???) */
556
557/* Line breaks just look back from the end and find the next break and try that. */
558
559 if (!(es->style & ES_AUTOHSCROLL)) {
560 if (current_line->width > fw && fw > es->char_width) {
561
562 INT prev, next;
563 int w;
564 const SIZE *sz;
565 float d;
566
567 prev = current_line->net_length - 1;
568 w = current_line->net_length;
569 d = (float)current_line->width/(float)fw;
570 if (d > 1.2f) d -= 0.2f;
571 next = prev/d;
572 if (next >= prev) next = prev-1;
573 do {
574 prev = EDIT_CallWordBreakProc(es, current_position - es->text,
575 next, current_line->net_length, WB_LEFT);
576 current_line->net_length = prev;
577 EDIT_InvalidateUniscribeData_linedef(current_line);
578 EDIT_UpdateUniscribeData_linedef(es, NULL, current_line);
579 if (current_line->ssa)
580 sz = ScriptString_pSize(current_line->ssa);
581 else sz = 0;
582 if (sz)
583 current_line->width = sz->cx;
584 else
585 prev = 0;
586 next = prev - 1;
587 } while (prev && current_line->width > fw);
588 current_line->net_length = w;
589
590 if (prev == 0) { /* Didn't find a line break so force a break */
591 INT *piDx;
592 const INT *count;
593
594 EDIT_InvalidateUniscribeData_linedef(current_line);
595 EDIT_UpdateUniscribeData_linedef(es, NULL, current_line);
596
597 if (current_line->ssa)
598 {
599 count = ScriptString_pcOutChars(current_line->ssa);
600 piDx = heap_alloc(sizeof(INT) * (*count));
601 ScriptStringGetLogicalWidths(current_line->ssa,piDx);
602
603 prev = current_line->net_length-1;
604 do {
605 current_line->width -= piDx[prev];
606 prev--;
607 } while ( prev > 0 && current_line->width > fw);
608 if (prev<=0)
609 prev = 1;
610 heap_free(piDx);
611 }
612 else
613 prev = (fw / es->char_width);
614 }
615
616 /* If the first line we are calculating, wrapped before istart, we must
617 * adjust istart in order for this to be reflected in the update region. */
618 if (current_line->index == nstart_index && istart > current_line->index + prev)
619 istart = current_line->index + prev;
620 /* else if we are updating the previous line before the first line we
621 * are re-calculating and it expanded */
622 else if (current_line == start_line &&
623 current_line->index != nstart_index && orig_net_length < prev)
624 {
625 /* Line expanded due to an upwards line wrap so we must partially include
626 * previous line in update region */
627 nstart_line = line_index;
628 nstart_index = current_line->index;
629 istart = current_line->index + orig_net_length;
630 }
631
632 current_line->net_length = prev;
633 current_line->ending = END_WRAP;
634
635 if (current_line->net_length > 0)
636 {
637 EDIT_UpdateUniscribeData_linedef(es, NULL, current_line);
638 if (current_line->ssa)
639 {
640 sz = ScriptString_pSize(current_line->ssa);
641 current_line->width = sz->cx;
642 }
643 else
644 current_line->width = 0;
645 }
646 else current_line->width = 0;
647 }
648 else if (current_line == start_line &&
649 current_line->index != nstart_index &&
650 orig_net_length < current_line->net_length) {
651 /* The previous line expanded but it's still not as wide as the client rect */
652 /* The expansion is due to an upwards line wrap so we must partially include
653 it in the update region */
654 nstart_line = line_index;
655 nstart_index = current_line->index;
656 istart = current_line->index + orig_net_length;
657 }
658 }
659
660
661 /* Adjust length to include line termination */
662 switch (current_line->ending) {
663 case END_SOFT:
664 current_line->length = current_line->net_length + 3;
665 break;
666 case END_RICH:
667 current_line->length = current_line->net_length + 1;
668 break;
669 case END_HARD:
670 current_line->length = current_line->net_length + 2;
671 break;
672 case END_WRAP:
673 case END_0:
674 current_line->length = current_line->net_length;
675 break;
676 }
677 es->text_width = max(es->text_width, current_line->width);
678 current_position += current_line->length;
679 previous_line = current_line;
680
681 /* Discard data for non-visible lines. It will be calculated as needed */
682 if ((line_index < es->y_offset) || (line_index > es->y_offset + vlc))
683 EDIT_InvalidateUniscribeData_linedef(current_line);
684
685 current_line = current_line->next;
686 line_index++;
687 } while (previous_line->ending != END_0);
688
689 /* Finish adjusting line indexes by delta or remove hanging lines */
690 if (previous_line->ending == END_0)
691 {
692 LINEDEF *pnext = NULL;
693
694 previous_line->next = NULL;
695 while (current_line)
696 {
697 pnext = current_line->next;
698 EDIT_InvalidateUniscribeData_linedef(current_line);
699 heap_free(current_line);
700 current_line = pnext;
701 es->line_count--;
702 }
703 }
704 else if (delta != 0)
705 {
706 while (current_line)
707 {
708 current_line->index += delta;
709 current_line = current_line->next;
710 }
711 }
712
713 /* Calculate rest of modification rectangle */
714 if (hrgn)
715 {
716 HRGN tmphrgn;
717 /*
718 * We calculate two rectangles. One for the first line which may have
719 * an indent with respect to the format rect. The other is a format-width
720 * rectangle that spans the rest of the lines that changed or moved.
721 */
722 rc.top = es->format_rect.top + nstart_line * es->line_height -
723 (es->y_offset * es->line_height); /* Adjust for vertical scrollbar */
724 rc.bottom = rc.top + es->line_height;
725 if ((es->style & ES_CENTER) || (es->style & ES_RIGHT))
726 rc.left = es->format_rect.left;
727 else
728#ifdef __REACTOS__ /* CORE-11475 */
729 rc.left = (short)LOWORD(EDIT_EM_PosFromChar(es, nstart_index, FALSE));
730#else
731 rc.left = LOWORD(EDIT_EM_PosFromChar(es, nstart_index, FALSE));
732#endif
733 rc.right = es->format_rect.right;
734 SetRectRgn(hrgn, rc.left, rc.top, rc.right, rc.bottom);
735
736 rc.top = rc.bottom;
737 rc.left = es->format_rect.left;
738 rc.right = es->format_rect.right;
739 /*
740 * If lines were added or removed we must re-paint the remainder of the
741 * lines since the remaining lines were either shifted up or down.
742 */
743 if (line_count < es->line_count) /* We added lines */
744 rc.bottom = es->line_count * es->line_height;
745 else if (line_count > es->line_count) /* We removed lines */
746 rc.bottom = line_count * es->line_height;
747 else
748 rc.bottom = line_index * es->line_height;
749 rc.bottom += es->format_rect.top;
750 rc.bottom -= (es->y_offset * es->line_height); /* Adjust for vertical scrollbar */
751 tmphrgn = CreateRectRgn(rc.left, rc.top, rc.right, rc.bottom);
752 CombineRgn(hrgn, hrgn, tmphrgn, RGN_OR);
753 DeleteObject(tmphrgn);
754 }
hrgn
static HRGN hrgn
Definition: NtGdiRestoreDC.c:14
heap_alloc
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
heap_free
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
FALSE
#define FALSE
Definition: types.h:117
EDIT_InvalidateUniscribeData_linedef
static void EDIT_InvalidateUniscribeData_linedef(LINEDEF *line_def)
Definition: edit.c:306
EDIT_UpdateUniscribeData_linedef
static SCRIPT_STRING_ANALYSIS EDIT_UpdateUniscribeData_linedef(EDITSTATE *es, HDC dc, LINEDEF *line_def)
Definition: edit.c:330
EDIT_EM_PosFromChar
static LRESULT EDIT_EM_PosFromChar(EDITSTATE *es, INT index, BOOL after_wrap)
Definition: edit.c:1013
EDIT_CallWordBreakProc
static INT EDIT_CallWordBreakProc(EDITSTATE *es, INT start, INT index, INT count, INT action)
Definition: edit.c:294
lstrlenW
#define lstrlenW
Definition: compat.h:750
text
const WCHAR * text
Definition: package.c:1794
ScriptStringGetLogicalWidths
HRESULT WINAPI ScriptStringGetLogicalWidths(SCRIPT_STRING_ANALYSIS ssa, int *piDx)
Definition: usp10.c:3804
ScriptString_pSize
const SIZE *WINAPI ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa)
Definition: usp10.c:3876
ScriptString_pcOutChars
const int *WINAPI ScriptString_pcOutChars(SCRIPT_STRING_ANALYSIS ssa)
Definition: usp10.c:3938
short
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
DeleteObject
pKey DeleteObject()
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
index
GLuint index
Definition: glext.h:6031
w
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
d
#define d
Definition: ke_i.h:81
cp
POINT cp
Definition: magnifier.c:59
float
static float(__cdecl *square_half_float)(float x
LOWORD
#define LOWORD(l)
Definition: pedump.c:82
ES_CENTER
#define ES_CENTER
Definition: pedump.c:665
ES_RIGHT
#define ES_RIGHT
Definition: pedump.c:666
next
static unsigned __int64 next
Definition: rand_nt.c:6
_SIZE
Definition: kdterminal.h:26
_SIZE::cx
LONG cx
Definition: kdterminal.h:27
tagLINEDEF::width
INT width
Definition: edit.c:89
tagLINEDEF::next
struct tagLINEDEF * next
Definition: edit.c:92
tagLINEDEF::length
INT length
Definition: edit.c:86
tagLINEDEF::ssa
SCRIPT_STRING_ANALYSIS ssa
Definition: edit.c:91
tagLINEDEF::index
INT index
Definition: edit.c:90
tagLINEDEF::net_length
INT net_length
Definition: edit.c:87
tagLINEDEF::ending
LINE_END ending
Definition: edit.c:88
tagRECT::right
LONG right
Definition: windef.h:308
tagRECT::top
LONG top
Definition: windef.h:307
tagRECT::left
LONG left
Definition: windef.h:306
CreateRectRgn
HRGN WINAPI CreateRectRgn(_In_ int, _In_ int, _In_ int, _In_ int)
CombineRgn
int WINAPI CombineRgn(_In_opt_ HRGN hrgnDest, _In_opt_ HRGN hrgnSrc1, _In_opt_ HRGN hrgnSrc2, _In_ int fnCombineMode)
RGN_OR
#define RGN_OR
Definition: wingdi.h:359
SetRectRgn
BOOL WINAPI SetRectRgn(_In_ HRGN, _In_ int, _In_ int, _In_ int, _In_ int)
WB_LEFT
#define WB_LEFT
Definition: winuser.h:550
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by EDIT_AdjustFormatRect(), EDIT_EM_ReplaceSel(), EDIT_EM_SetHandle(), EDIT_EM_SetWordBreakProc(), and EDIT_WM_SetFont().

◆ EDIT_CalcLineWidth_SL()

static void EDIT_CalcLineWidth_SL ( EDITSTATE *  es)
static

Definition at line 761 of file edit.c.

763{
764 EDIT_UpdateUniscribeData(es, NULL, 0);
765 if (es->ssa)
766 {
767 const SIZE *size;
768 size = ScriptString_pSize(es->ssa);
769 es->text_width = size->cx;
770 }
771 else
772 es->text_width = 0;
EDIT_UpdateUniscribeData
static SCRIPT_STRING_ANALYSIS EDIT_UpdateUniscribeData(EDITSTATE *es, HDC dc, INT line)
Definition: edit.c:372
size
GLsizeiptr size
Definition: glext.h:5919

Referenced by EDIT_EM_ReplaceSel(), and EDIT_WM_SetFont().

◆ EDIT_CallWordBreakProc()

static INT EDIT_CallWordBreakProc ( EDITSTATE *  es,
INT  start,
INT  index,
INT  count,
INT  action 
)
static

Definition at line 294 of file edit.c.

296{
297 INT ret;
298
299 if (es->word_break_proc)
300 ret = es->word_break_proc(es->text + start, index, count, action);
301 else
302 ret = EDIT_WordBreakProc(es, es->text, index + start, count + start, action) - start;
303
304 return ret;
EDIT_WordBreakProc
static INT EDIT_WordBreakProc(EDITSTATE *es, LPWSTR s, INT index, INT count, INT action)
Definition: edit.c:236
action
const WCHAR * action
Definition: action.c:7509
start
GLuint start
Definition: gl.h:1545
ret
int ret
Definition: wcstombs-tests.c:31

Referenced by EDIT_BuildLineDefs_ML(), EDIT_MoveWordBackward(), EDIT_MoveWordForward(), and EDIT_WM_LButtonDblClk().

◆ EDIT_CharFromPos()

static INT EDIT_CharFromPos ( EDITSTATE *  es,
INT  x,
INT  y,
LPBOOL  after_wrap 
)
static

Definition at line 784 of file edit.c.

786{
787 INT index;
788
789 if (es->style & ES_MULTILINE) {
790 int trailing;
791 INT line = (y - es->format_rect.top) / es->line_height + es->y_offset;
792 INT line_index = 0;
793 LINEDEF *line_def = es->first_line_def;
794 EDIT_UpdateUniscribeData(es, NULL, line);
795 while ((line > 0) && line_def->next) {
796 line_index += line_def->length;
797 line_def = line_def->next;
798 line--;
799 }
800
801 x += es->x_offset - es->format_rect.left;
802 if (es->style & ES_RIGHT)
803 x -= (es->format_rect.right - es->format_rect.left) - line_def->width;
804 else if (es->style & ES_CENTER)
805 x -= ((es->format_rect.right - es->format_rect.left) - line_def->width) / 2;
806 if (x >= line_def->width) {
807 if (after_wrap)
808 *after_wrap = (line_def->ending == END_WRAP);
809 return line_index + line_def->net_length;
810 }
811 if (x <= 0 || !line_def->ssa) {
812 if (after_wrap)
813 *after_wrap = FALSE;
814 return line_index;
815 }
816
817 ScriptStringXtoCP(line_def->ssa, x , &index, &trailing);
818 if (trailing) index++;
819 index += line_index;
820 if (after_wrap)
821 *after_wrap = ((index == line_index + line_def->net_length) &&
822 (line_def->ending == END_WRAP));
823 } else {
824 INT xoff = 0;
825 INT trailing;
826 if (after_wrap)
827 *after_wrap = FALSE;
828 x -= es->format_rect.left;
829 if (!x)
830 return es->x_offset;
831
832 if (!es->x_offset)
833 {
834 INT indent = (es->format_rect.right - es->format_rect.left) - es->text_width;
835 if (es->style & ES_RIGHT)
836 x -= indent;
837 else if (es->style & ES_CENTER)
838 x -= indent / 2;
839 }
840
841 EDIT_UpdateUniscribeData(es, NULL, 0);
842 if (es->x_offset)
843 {
844 if (es->ssa)
845 {
846 if (es->x_offset>= get_text_length(es))
847 {
848 const SIZE *size;
849 size = ScriptString_pSize(es->ssa);
850 xoff = size->cx;
851 }
852 ScriptStringCPtoX(es->ssa, es->x_offset, FALSE, &xoff);
853 }
854 else
855 xoff = 0;
856 }
857 if (x < 0)
858 {
859 if (x + xoff > 0 || !es->ssa)
860 {
861 ScriptStringXtoCP(es->ssa, x+xoff, &index, &trailing);
862 if (trailing) index++;
863 }
864 else
865 index = 0;
866 }
867 else
868 {
869 if (x)
870 {
871 const SIZE *size = NULL;
872 if (es->ssa)
873 size = ScriptString_pSize(es->ssa);
874 if (!size)
875 index = 0;
876 else if (x > size->cx)
877 index = get_text_length(es);
878 else if (es->ssa)
879 {
880 ScriptStringXtoCP(es->ssa, x+xoff, &index, &trailing);
881 if (trailing) index++;
882 }
883 else
884 index = 0;
885 }
886 else
887 index = es->x_offset;
888 }
889 }
890 return index;
index
#define index(s, c)
Definition: various.h:29
indent
static const WCHAR indent[]
Definition: object.c:1156
ScriptStringXtoCP
HRESULT WINAPI ScriptStringXtoCP(SCRIPT_STRING_ANALYSIS ssa, int iX, int *piCh, int *piTrailing)
Definition: usp10.c:2474
ScriptStringCPtoX
HRESULT WINAPI ScriptStringCPtoX(SCRIPT_STRING_ANALYSIS ssa, int icp, BOOL fTrailing, int *pX)
Definition: usp10.c:2411
x
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
y
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
if
if(dx< 0)
Definition: linetemp.h:194
line
Definition: parser.c:49

Referenced by EDIT_EM_CharFromPos(), EDIT_MoveDown_ML(), EDIT_MoveEnd(), EDIT_MoveHome(), EDIT_MovePageDown_ML(), EDIT_MovePageUp_ML(), EDIT_MoveUp_ML(), EDIT_WM_LButtonDown(), and EDIT_WM_MouseMove().

◆ EDIT_CheckCombo()

static BOOL EDIT_CheckCombo ( EDITSTATE *  es,
UINT  msg,
INT  key 
)
static

Definition at line 3281 of file edit.c.

3283{
3284 HWND hLBox = es->hwndListBox;
3285 HWND hCombo;
3286 BOOL bDropped;
3287 int nEUI;
3288
3289 if (!hLBox)
3290 return FALSE;
3291
3292 hCombo = GetParent(es->hwndSelf);
3293 bDropped = TRUE;
3294 nEUI = 0;
3295
3296 TRACE("[%p]: handling msg %x (%x)\n", es->hwndSelf, msg, key);
3297
3298 if (key == VK_UP || key == VK_DOWN)
3299 {
3300 if (SendMessageW(hCombo, CB_GETEXTENDEDUI, 0, 0))
3301 nEUI = 1;
3302
3303 if (msg == WM_KEYDOWN || nEUI)
3304 bDropped = (BOOL)SendMessageW(hCombo, CB_GETDROPPEDSTATE, 0, 0);
3305 }
3306
3307 switch (msg)
3308 {
3309 case WM_KEYDOWN:
3310 if (!bDropped && nEUI && (key == VK_UP || key == VK_DOWN))
3311 {
3312 /* make sure ComboLBox pops up */
3313 SendMessageW(hCombo, CB_SETEXTENDEDUI, FALSE, 0);
3314 key = VK_F4;
3315 nEUI = 2;
3316 }
3317
3318 SendMessageW(hLBox, WM_KEYDOWN, key, 0);
3319 break;
3320
3321 case WM_SYSKEYDOWN: /* Handle Alt+up/down arrows */
3322 if (nEUI)
3323 SendMessageW(hCombo, CB_SHOWDROPDOWN, !bDropped, 0);
3324 else
3325 SendMessageW(hLBox, WM_KEYDOWN, VK_F4, 0);
3326 break;
3327 }
3328
3329 if (nEUI == 2)
3330 SendMessageW(hCombo, CB_SETEXTENDEDUI, TRUE, 0);
3331
3332 return TRUE;
msg
#define msg(x)
Definition: auth_time.c:54
TRUE
#define TRUE
Definition: types.h:120
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
BOOL
#define BOOL
Definition: nt_native.h:43
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
key
Definition: copy.c:22
CB_SHOWDROPDOWN
#define CB_SHOWDROPDOWN
Definition: winuser.h:1973
VK_UP
#define VK_UP
Definition: winuser.h:2228
VK_F4
#define VK_F4
Definition: winuser.h:2261
CB_GETDROPPEDSTATE
#define CB_GETDROPPEDSTATE
Definition: winuser.h:1948
GetParent
HWND WINAPI GetParent(_In_ HWND)
CB_GETEXTENDEDUI
#define CB_GETEXTENDEDUI
Definition: winuser.h:1951
VK_DOWN
#define VK_DOWN
Definition: winuser.h:2230
WM_KEYDOWN
#define WM_KEYDOWN
Definition: winuser.h:1718
CB_SETEXTENDEDUI
#define CB_SETEXTENDEDUI
Definition: winuser.h:1967
WM_SYSKEYDOWN
#define WM_SYSKEYDOWN
Definition: winuser.h:1722
SendMessageW
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by EDIT_WM_KeyDown(), and EDIT_WM_SysKeyDown().

◆ EDIT_ConfinePoint()

static void EDIT_ConfinePoint ( const EDITSTATE *  es,
LPINT  x,
LPINT  y 
)
static

Definition at line 901 of file edit.c.

903{
904 *x = min(max(*x, es->format_rect.left), es->format_rect.right - 1);
905 *y = min(max(*y, es->format_rect.top), es->format_rect.bottom - 1);

Referenced by EDIT_WM_LButtonDown(), and EDIT_WM_MouseMove().

◆ EDIT_ContextMenuCommand()

static void EDIT_ContextMenuCommand ( EDITSTATE *  es,
UINT  id 
)
static

Definition at line 3167 of file edit.c.

3169{
3170 switch (id) {
3171 case EM_UNDO:
3172 SendMessageW(es->hwndSelf, WM_UNDO, 0, 0);
3173 break;
3174 case WM_CUT:
3175 SendMessageW(es->hwndSelf, WM_CUT, 0, 0);
3176 break;
3177 case WM_COPY:
3178 SendMessageW(es->hwndSelf, WM_COPY, 0, 0);
3179 break;
3180 case WM_PASTE:
3181 SendMessageW(es->hwndSelf, WM_PASTE, 0, 0);
3182 break;
3183 case WM_CLEAR:
3184 SendMessageW(es->hwndSelf, WM_CLEAR, 0, 0);
3185 break;
3186 case EM_SETSEL:
3187 SendMessageW(es->hwndSelf, EM_SETSEL, 0, -1);
3188 break;
3189 default:
3190 ERR("unknown menu item, please report\n");
3191 break;
3192 }
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
WM_PASTE
#define WM_PASTE
Definition: winuser.h:1866
WM_CUT
#define WM_CUT
Definition: winuser.h:1864
WM_UNDO
#define WM_UNDO
Definition: winuser.h:1868
EM_UNDO
#define EM_UNDO
Definition: winuser.h:2024
EM_SETSEL
#define EM_SETSEL
Definition: winuser.h:2021
WM_COPY
#define WM_COPY
Definition: winuser.h:1865
WM_CLEAR
#define WM_CLEAR
Definition: winuser.h:1867

Referenced by EDIT_WM_ContextMenu().

◆ EDIT_EM_CanUndo()

static BOOL EDIT_EM_CanUndo ( const EDITSTATE *  es)
inlinestatic

Definition at line 181 of file edit.c.

183{
184 return (es->undo_insert_count || lstrlenW(es->undo_text));

Referenced by EDIT_WindowProc(), EDIT_WM_ContextMenu(), EDIT_WM_SysKeyDown(), and EditWndProc_common().

◆ EDIT_EM_CharFromPos()

static LRESULT EDIT_EM_CharFromPos ( EDITSTATE *  es,
INT  x,
INT  y 
)
static

Definition at line 2363 of file edit.c.

2365{
2366 POINT pt;
2367 RECT rc;
2368 INT index;
2369
2370 pt.x = x;
2371 pt.y = y;
2372 GetClientRect(es->hwndSelf, &rc);
2373 if (!PtInRect(&rc, pt))
2374 return -1;
2375
2376 index = EDIT_CharFromPos(es, x, y, NULL);
2377 return MAKELONG(index, EDIT_EM_LineFromChar(es, index));
EDIT_CharFromPos
static INT EDIT_CharFromPos(EDITSTATE *es, INT x, INT y, LPBOOL after_wrap)
Definition: edit.c:784
EDIT_EM_LineFromChar
static INT EDIT_EM_LineFromChar(EDITSTATE *es, INT index)
Definition: edit.c:913
pt
#define pt(x, y)
Definition: drawing.c:79
MAKELONG
#define MAKELONG(a, b)
Definition: typedefs.h:249
PtInRect
BOOL WINAPI PtInRect(_In_ LPCRECT, _In_ POINT)

Referenced by EDIT_WindowProc().

◆ EDIT_EM_EmptyUndoBuffer()

static void EDIT_EM_EmptyUndoBuffer ( EDITSTATE *  es)
inlinestatic

Definition at line 192 of file edit.c.

194{
195 es->undo_insert_count = 0;
196 *es->undo_text = '\0';

Referenced by EDIT_EM_ReplaceSel(), EDIT_EM_SetHandle(), EDIT_EM_Undo(), EDIT_WindowProc(), EDIT_WM_Create(), and EditWndProc_common().

◆ EDIT_EM_FmtLines()

static BOOL EDIT_EM_FmtLines ( EDITSTATE *  es,
BOOL  add_eol 
)
static

Definition at line 2391 of file edit.c.

2393{
2394 es->flags &= ~EF_USE_SOFTBRK;
2395 if (add_eol) {
2396 es->flags |= EF_USE_SOFTBRK;
2397 FIXME("soft break enabled, not implemented\n");
2398 }
2399 return add_eol;
EF_USE_SOFTBRK
#define EF_USE_SOFTBRK
Definition: edit.c:71

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetCueBanner()

static BOOL EDIT_EM_GetCueBanner ( EDITSTATE *  es,
WCHAR *  buf,
DWORD  size 
)
static

Definition at line 4342 of file edit.c.

4344{
4345 if (es->style & ES_MULTILINE)
4346 return FALSE;
4347
4348 if (!es->cue_banner_text)
4349 {
4350 if (buf && size)
4351 *buf = 0;
4352 return FALSE;
4353 }
4354 else
4355 {
4356 if (buf)
4357 lstrcpynW(buf, es->cue_banner_text, size);
4358 return TRUE;
4359 }
lstrcpynW
#define lstrcpynW
Definition: compat.h:738
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751

Referenced by EDIT_WindowProc().

◆ EDIT_EM_GetHandle()

static HLOCAL EDIT_EM_GetHandle ( EDITSTATE *  es)
static

Definition at line 2413 of file edit.c.

2415{
2416 if (!(es->style & ES_MULTILINE))
2417 return 0;
2418
2419 EDIT_UnlockBuffer(es, TRUE);
2420
2421 /* The text buffer handle belongs to the app */
2422 es->hlocapp = es->hloc32W;
2423
2424 TRACE("Returning %p, LocalSize() = %ld\n", es->hlocapp, LocalSize(es->hlocapp));
2425 return es->hlocapp;
EDIT_UnlockBuffer
static void EDIT_UnlockBuffer(EDITSTATE *es, BOOL force)
Definition: edit.c:1230
LocalSize
SIZE_T NTAPI LocalSize(HLOCAL hMem)
Definition: heapmem.c:1794

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetLine()

static INT EDIT_EM_GetLine ( EDITSTATE *  es,
INT  line,
LPWSTR  dst 
)
static

Definition at line 2433 of file edit.c.

2435{
2436 INT line_len, dst_len;
2437 LPWSTR src;
2438 INT i;
2439
2440 if (es->style & ES_MULTILINE)
2441 {
2442 if (line >= es->line_count)
2443 return 0;
2444 }
2445 else
2446 line = 0;
2447
2448 i = EDIT_EM_LineIndex(es, line);
2449 src = es->text + i;
2450 line_len = EDIT_EM_LineLength(es, i);
2451 dst_len = *(WORD *)dst;
2452
2453 if (dst_len <= line_len)
2454 {
2455 memcpy(dst, src, dst_len * sizeof(WCHAR));
2456 return dst_len;
2457 }
2458 else /* Append 0 if enough space */
2459 {
2460 memcpy(dst, src, line_len * sizeof(WCHAR));
2461 dst[line_len] = 0;
2462 return line_len;
2463 }
EDIT_EM_LineIndex
static INT EDIT_EM_LineIndex(const EDITSTATE *es, INT line)
Definition: edit.c:942
EDIT_EM_LineLength
static INT EDIT_EM_LineLength(EDITSTATE *es, INT index)
Definition: edit.c:977
WORD
unsigned short WORD
Definition: ntddk_ex.h:93
src
GLenum src
Definition: glext.h:6340
dst
GLenum GLenum dst
Definition: glext.h:6340
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetSel()

static LRESULT EDIT_EM_GetSel ( const EDITSTATE *  es,
PUINT  start,
PUINT  end 
)
static

Definition at line 2471 of file edit.c.

2473{
2474 UINT s = es->selection_start;
2475 UINT e = es->selection_end;
2476
2477 ORDER_UINT(s, e);
2478 if (start)
2479 *start = s;
2480 if (end)
2481 *end = e;
2482 return MAKELONG(s, e);
ORDER_UINT
#define ORDER_UINT(x, y)
Definition: edit.c:164
s
GLdouble s
Definition: gl.h:2039
end
GLuint GLuint end
Definition: gl.h:1545
e
#define e
Definition: ke_i.h:82
UINT
unsigned int UINT
Definition: ndis.h:50

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetThumb()

static LRESULT EDIT_EM_GetThumb ( EDITSTATE *  es)
static

Definition at line 4306 of file edit.c.

4308{
4309 return MAKELONG(EDIT_WM_VScroll(es, EM_GETTHUMB, 0),
4310 EDIT_WM_HScroll(es, EM_GETTHUMB, 0));
EDIT_WM_HScroll
static LRESULT EDIT_WM_HScroll(EDITSTATE *es, INT action, INT pos)
Definition: edit.c:4054
EDIT_WM_VScroll
static LRESULT EDIT_WM_VScroll(EDITSTATE *es, INT action, INT pos)
Definition: edit.c:4186
EM_GETTHUMB
#define EM_GETTHUMB
Definition: winuser.h:2001

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_LineFromChar()

static INT EDIT_EM_LineFromChar ( EDITSTATE *  es,
INT  index 
)
static

Definition at line 913 of file edit.c.

915{
916 INT line;
917 LINEDEF *line_def;
918
919 if (!(es->style & ES_MULTILINE))
920 return 0;
921 if (index > (INT)get_text_length(es))
922 return es->line_count - 1;
923 if (index == -1)
924 index = min(es->selection_start, es->selection_end);
925
926 line = 0;
927 line_def = es->first_line_def;
928 index -= line_def->length;
929 while ((index >= 0) && line_def->next) {
930 line++;
931 line_def = line_def->next;
932 index -= line_def->length;
933 }
934 return line;

Referenced by EDIT_EM_CharFromPos(), EDIT_EM_LineLength(), EDIT_EM_PosFromChar(), EDIT_EM_ScrollCaret(), EDIT_ML_InvalidateText(), EDIT_MoveWordBackward(), EDIT_MoveWordForward(), EDIT_WindowProc(), EDIT_WM_LButtonDblClk(), and EditWndProc_common().

◆ EDIT_EM_LineIndex()

static INT EDIT_EM_LineIndex ( const EDITSTATE *  es,
INT  line 
)
static

Definition at line 942 of file edit.c.

944{
945 INT line_index;
946 const LINEDEF *line_def;
947
948 if (!(es->style & ES_MULTILINE))
949 return 0;
950 if (line >= es->line_count)
951 return -1;
952
953 line_index = 0;
954 line_def = es->first_line_def;
955 if (line == -1) {
956 INT index = es->selection_end - line_def->length;
957 while ((index >= 0) && line_def->next) {
958 line_index += line_def->length;
959 line_def = line_def->next;
960 index -= line_def->length;
961 }
962 } else {
963 while (line > 0) {
964 line_index += line_def->length;
965 line_def = line_def->next;
966 line--;
967 }
968 }
969 return line_index;

Referenced by EDIT_EM_GetLine(), EDIT_EM_LineLength(), EDIT_EM_PosFromChar(), EDIT_ML_InvalidateText(), EDIT_MoveWordBackward(), EDIT_MoveWordForward(), EDIT_PaintLine(), EDIT_PaintText(), EDIT_WindowProc(), EDIT_WM_LButtonDblClk(), and EditWndProc_common().

◆ EDIT_EM_LineLength()

static INT EDIT_EM_LineLength ( EDITSTATE *  es,
INT  index 
)
static

Definition at line 977 of file edit.c.

979{
980 LINEDEF *line_def;
981
982 if (!(es->style & ES_MULTILINE))
983 return get_text_length(es);
984
985 if (index == -1) {
986 /* get the number of remaining non-selected chars of selected lines */
987 INT32 l; /* line number */
988 INT32 li; /* index of first char in line */
989 INT32 count;
990 l = EDIT_EM_LineFromChar(es, es->selection_start);
991 /* # chars before start of selection area */
992 count = es->selection_start - EDIT_EM_LineIndex(es, l);
993 l = EDIT_EM_LineFromChar(es, es->selection_end);
994 /* # chars after end of selection */
995 li = EDIT_EM_LineIndex(es, l);
996 count += li + EDIT_EM_LineLength(es, li) - es->selection_end;
997 return count;
998 }
999 line_def = es->first_line_def;
1000 index -= line_def->length;
1001 while ((index >= 0) && line_def->next) {
1002 line_def = line_def->next;
1003 index -= line_def->length;
1004 }
1005 return line_def->net_length;
INT32
signed int INT32
Definition: ProcessorBind.h:167
l
r l[0]
Definition: byte_order.h:168
li
LARGE_INTEGER li
Definition: fxtimerapi.cpp:235

Referenced by EDIT_EM_GetLine(), EDIT_EM_LineLength(), EDIT_ML_InvalidateText(), EDIT_MoveWordBackward(), EDIT_MoveWordForward(), EDIT_PaintLine(), EDIT_WindowProc(), EDIT_WM_LButtonDblClk(), and EditWndProc_common().

◆ EDIT_EM_LineScroll()

static BOOL EDIT_EM_LineScroll ( EDITSTATE *  es,
INT  dx,
INT  dy 
)
static

Definition at line 1657 of file edit.c.

1659{
1660 if (!(es->style & ES_MULTILINE))
1661 return FALSE;
1662
1663 dx *= es->char_width;
1664 return EDIT_EM_LineScroll_internal(es, dx, dy);
EDIT_EM_LineScroll_internal
static BOOL EDIT_EM_LineScroll_internal(EDITSTATE *es, INT dx, INT dy)
Definition: edit.c:1601
dy
GLint dy
Definition: linetemp.h:97
dx
GLint dx
Definition: linetemp.h:97

Referenced by EDIT_EM_Scroll(), EDIT_WindowProc(), EDIT_WM_VScroll(), and EditWndProc_common().

◆ EDIT_EM_LineScroll_internal()

static BOOL EDIT_EM_LineScroll_internal ( EDITSTATE *  es,
INT  dx,
INT  dy 
)
static

Definition at line 1601 of file edit.c.

1603{
1604 INT nyoff;
1605 INT x_offset_in_pixels;
1606 INT lines_per_page = (es->format_rect.bottom - es->format_rect.top) /
1607 es->line_height;
1608
1609 if (es->style & ES_MULTILINE)
1610 {
1611 x_offset_in_pixels = es->x_offset;
1612 }
1613 else
1614 {
1615 dy = 0;
1616 x_offset_in_pixels = (short)LOWORD(EDIT_EM_PosFromChar(es, es->x_offset, FALSE));
1617 }
1618
1619 if (-dx > x_offset_in_pixels)
1620 dx = -x_offset_in_pixels;
1621 if (dx > es->text_width - x_offset_in_pixels)
1622 dx = es->text_width - x_offset_in_pixels;
1623 nyoff = max(0, es->y_offset + dy);
1624 if (nyoff >= es->line_count - lines_per_page)
1625 nyoff = max(0, es->line_count - lines_per_page);
1626 dy = (es->y_offset - nyoff) * es->line_height;
1627 if (dx || dy) {
1628 RECT rc1;
1629 RECT rc;
1630
1631 es->y_offset = nyoff;
1632 if(es->style & ES_MULTILINE)
1633 es->x_offset += dx;
1634 else
1635 es->x_offset += dx / es->char_width;
1636
1637 GetClientRect(es->hwndSelf, &rc1);
1638 IntersectRect(&rc, &rc1, &es->format_rect);
1639 ScrollWindowEx(es->hwndSelf, -dx, dy,
1640 NULL, &rc, NULL, NULL, SW_INVALIDATE);
1641 /* force scroll info update */
1642 EDIT_UpdateScrollInfo(es);
1643 }
1644 if (dx && !(es->flags & EF_HSCROLL_TRACK))
1645 notify_parent(es, EN_HSCROLL);
1646 if (dy && !(es->flags & EF_VSCROLL_TRACK))
1647 notify_parent(es, EN_VSCROLL);
1648 return TRUE;
notify_parent
static BOOL notify_parent(const EDITSTATE *es, INT code)
Definition: edit.c:166
EF_HSCROLL_TRACK
#define EF_HSCROLL_TRACK
Definition: edit.c:69
EF_VSCROLL_TRACK
#define EF_VSCROLL_TRACK
Definition: edit.c:68
SW_INVALIDATE
#define SW_INVALIDATE
Definition: winuser.h:2582
EN_HSCROLL
#define EN_HSCROLL
Definition: winuser.h:2027
IntersectRect
BOOL WINAPI IntersectRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
EN_VSCROLL
#define EN_VSCROLL
Definition: winuser.h:2032
ScrollWindowEx
int WINAPI ScrollWindowEx(_In_ HWND, _In_ int, _In_ int, _In_opt_ LPCRECT, _In_opt_ LPCRECT, _In_opt_ HRGN, _Out_opt_ LPRECT, _In_ UINT)

Referenced by EDIT_EM_LineScroll(), EDIT_EM_ScrollCaret(), and EDIT_WM_HScroll().

◆ EDIT_EM_PosFromChar()

static LRESULT EDIT_EM_PosFromChar ( EDITSTATE *  es,
INT  index,
BOOL  after_wrap 
)
static

Definition at line 1013 of file edit.c.

1015{
1016 INT len = get_text_length(es);
1017 INT l;
1018 INT li;
1019 INT x = 0;
1020 INT y = 0;
1021 INT w;
1022 INT lw;
1023 LINEDEF *line_def;
1024
1025 index = min(index, len);
1026 if (es->style & ES_MULTILINE) {
1027 l = EDIT_EM_LineFromChar(es, index);
1028 EDIT_UpdateUniscribeData(es, NULL, l);
1029
1030 y = (l - es->y_offset) * es->line_height;
1031 li = EDIT_EM_LineIndex(es, l);
1032 if (after_wrap && (li == index) && l) {
1033 INT l2 = l - 1;
1034 line_def = es->first_line_def;
1035 while (l2) {
1036 line_def = line_def->next;
1037 l2--;
1038 }
1039 if (line_def->ending == END_WRAP) {
1040 l--;
1041 y -= es->line_height;
1042 li = EDIT_EM_LineIndex(es, l);
1043 }
1044 }
1045
1046 line_def = es->first_line_def;
1047 while (line_def->index != li)
1048 line_def = line_def->next;
1049
1050 lw = line_def->width;
1051 w = es->format_rect.right - es->format_rect.left;
1052 if (line_def->ssa)
1053#ifdef __REACTOS__ /* CORE-19731 & match win32ss/user/user32/controls/edit.c */
1054 {
1055 ScriptStringCPtoX(line_def->ssa, (index - 1) - li, TRUE, &x);
1056 x -= es->x_offset;
1057 }
1058 else
1059#else
1060 ScriptStringCPtoX(line_def->ssa, (index - 1) - li, TRUE, &x);
1061#endif
1062#ifdef __REACTOS__ /* CORE-15780 */
1063 x = (lw > 0 ? es->x_offset : x - es->x_offset);
1064#else
1065 x = es->x_offset;
1066#endif
1067
1068 if (es->style & ES_RIGHT)
1069 x = w - (lw - x);
1070 else if (es->style & ES_CENTER)
1071 x += (w - lw) / 2;
1072 } else {
1073 INT xoff = 0;
1074 INT xi = 0;
1075 EDIT_UpdateUniscribeData(es, NULL, 0);
1076 if (es->x_offset)
1077 {
1078 if (es->ssa)
1079 {
1080 if (es->x_offset >= get_text_length(es))
1081 {
1082 int leftover = es->x_offset - get_text_length(es);
1083 if (es->ssa)
1084 {
1085 const SIZE *size;
1086 size = ScriptString_pSize(es->ssa);
1087 xoff = size->cx;
1088 }
1089 else
1090 xoff = 0;
1091 xoff += es->char_width * leftover;
1092 }
1093 else
1094 ScriptStringCPtoX(es->ssa, es->x_offset, FALSE, &xoff);
1095 }
1096 else
1097 xoff = 0;
1098 }
1099 if (index)
1100 {
1101 if (index >= get_text_length(es))
1102 {
1103 if (es->ssa)
1104 {
1105 const SIZE *size;
1106 size = ScriptString_pSize(es->ssa);
1107 xi = size->cx;
1108 }
1109 else
1110 xi = 0;
1111 }
1112 else if (es->ssa)
1113 ScriptStringCPtoX(es->ssa, index, FALSE, &xi);
1114 else
1115 xi = 0;
1116 }
1117 x = xi - xoff;
1118
1119 if (index >= es->x_offset) {
1120 if (!es->x_offset && (es->style & (ES_RIGHT | ES_CENTER)))
1121 {
1122 w = es->format_rect.right - es->format_rect.left;
1123 if (w > es->text_width)
1124 {
1125 if (es->style & ES_RIGHT)
1126 x += w - es->text_width;
1127 else if (es->style & ES_CENTER)
1128 x += (w - es->text_width) / 2;
1129 }
1130 }
1131 }
1132 y = 0;
1133 }
1134 x += es->format_rect.left;
1135 y += es->format_rect.top;
1136 return MAKELONG((INT16)x, (INT16)y);
INT16
signed short INT16
Definition: ProcessorBind.h:180
len
GLenum GLsizei len
Definition: glext.h:6722

Referenced by EDIT_BuildLineDefs_ML(), EDIT_EM_LineScroll_internal(), EDIT_EM_ScrollCaret(), EDIT_GetLineRect(), EDIT_MoveDown_ML(), EDIT_MoveEnd(), EDIT_MoveHome(), EDIT_MovePageDown_ML(), EDIT_MovePageUp_ML(), EDIT_MoveUp_ML(), EDIT_PaintLine(), EDIT_SetCaretPos(), and EDIT_WindowProc().

◆ EDIT_EM_ReplaceSel()

static void EDIT_EM_ReplaceSel ( EDITSTATE *  es,
BOOL  can_undo,
const WCHAR *  lpsz_replace,
UINT  strl,
BOOL  send_update,
BOOL  honor_limit 
)
static

Definition at line 2492 of file edit.c.

2495{
2496 UINT tl = get_text_length(es);
2497 UINT utl;
2498 UINT s;
2499 UINT e;
2500 UINT i;
2501 UINT size;
2502 LPWSTR p;
2503 HRGN hrgn = 0;
2504 LPWSTR buf = NULL;
2505 UINT bufl;
2506
2507 TRACE("%s, can_undo %d, send_update %d\n",
2508 debugstr_wn(lpsz_replace, strl), can_undo, send_update);
2509
2510 s = es->selection_start;
2511 e = es->selection_end;
2512
2513 EDIT_InvalidateUniscribeData(es);
2514 if ((s == e) && !strl)
2515 return;
2516
2517 ORDER_UINT(s, e);
2518
2519 size = tl - (e - s) + strl;
2520 if (!size)
2521 es->text_width = 0;
2522
2523 /* Issue the EN_MAXTEXT notification and continue with replacing text
2524 * so that buffer limit is honored. */
2525 if ((honor_limit) && (size > es->buffer_limit))
2526 {
2527 if (!notify_parent(es, EN_MAXTEXT)) return;
2528 /* Buffer limit can be smaller than the actual length of text in combobox */
2529 if (es->buffer_limit < (tl - (e-s)))
2530 strl = 0;
2531 else
2532 strl = min(strl, es->buffer_limit - (tl - (e-s)));
2533 }
2534
2535 if (!EDIT_MakeFit(es, tl - (e - s) + strl))
2536 return;
2537
2538 if (e != s) {
2539 /* there is something to be deleted */
2540 TRACE("deleting stuff.\n");
2541 bufl = e - s;
2542 buf = heap_alloc((bufl + 1) * sizeof(WCHAR));
2543 if (!buf) return;
2544 memcpy(buf, es->text + s, bufl * sizeof(WCHAR));
2545 buf[bufl] = 0; /* ensure 0 termination */
2546 /* now delete */
2547 lstrcpyW(es->text + s, es->text + e);
2548 text_buffer_changed(es);
2549 }
2550 if (strl) {
2551 /* there is an insertion */
2552 tl = get_text_length(es);
2553 TRACE("inserting stuff (tl %d, strl %d, selstart %d (%s), text %s)\n", tl, strl, s, debugstr_w(es->text + s), debugstr_w(es->text));
2554 for (p = es->text + tl ; p >= es->text + s ; p--)
2555 p[strl] = p[0];
2556 for (i = 0 , p = es->text + s ; i < strl ; i++)
2557 p[i] = lpsz_replace[i];
2558 if(es->style & ES_UPPERCASE)
2559 CharUpperBuffW(p, strl);
2560 else if(es->style & ES_LOWERCASE)
2561 CharLowerBuffW(p, strl);
2562 text_buffer_changed(es);
2563 }
2564 if (es->style & ES_MULTILINE)
2565 {
2566 INT st = min(es->selection_start, es->selection_end);
2567 INT vlc = get_vertical_line_count(es);
2568
2569 hrgn = CreateRectRgn(0, 0, 0, 0);
2570 EDIT_BuildLineDefs_ML(es, st, st + strl,
2571 strl - abs(es->selection_end - es->selection_start), hrgn);
2572 /* if text is too long undo all changes */
2573 if (honor_limit && !(es->style & ES_AUTOVSCROLL) && (es->line_count > vlc)) {
2574 if (strl)
2575 lstrcpyW(es->text + e, es->text + e + strl);
2576 if (e != s)
2577 for (i = 0 , p = es->text ; i < e - s ; i++)
2578 p[i + s] = buf[i];
2579 text_buffer_changed(es);
2580 EDIT_BuildLineDefs_ML(es, s, e,
2581 abs(es->selection_end - es->selection_start) - strl, hrgn);
2582 strl = 0;
2583 e = s;
2584 SetRectRgn(hrgn, 0, 0, 0, 0);
2585 if (!notify_parent(es, EN_MAXTEXT)) return;
2586 }
2587 }
2588 else {
2589 INT fw = es->format_rect.right - es->format_rect.left;
2590 EDIT_InvalidateUniscribeData(es);
2591 EDIT_CalcLineWidth_SL(es);
2592 /* remove chars that don't fit */
2593 if (honor_limit && !(es->style & ES_AUTOHSCROLL) && (es->text_width > fw)) {
2594 while ((es->text_width > fw) && s + strl >= s) {
2595 lstrcpyW(es->text + s + strl - 1, es->text + s + strl);
2596 strl--;
2597 es->text_length = -1;
2598 EDIT_InvalidateUniscribeData(es);
2599 EDIT_CalcLineWidth_SL(es);
2600 }
2601 text_buffer_changed(es);
2602 if (!notify_parent(es, EN_MAXTEXT)) return;
2603 }
2604 }
2605
2606 if (e != s) {
2607 if (can_undo) {
2608 utl = lstrlenW(es->undo_text);
2609 if (!es->undo_insert_count && (*es->undo_text && (s == es->undo_position))) {
2610 /* undo-buffer is extended to the right */
2611 EDIT_MakeUndoFit(es, utl + e - s);
2612 memcpy(es->undo_text + utl, buf, (e - s)*sizeof(WCHAR));
2613 (es->undo_text + utl)[e - s] = 0; /* ensure 0 termination */
2614 } else if (!es->undo_insert_count && (*es->undo_text && (e == es->undo_position))) {
2615 /* undo-buffer is extended to the left */
2616 EDIT_MakeUndoFit(es, utl + e - s);
2617 for (p = es->undo_text + utl ; p >= es->undo_text ; p--)
2618 p[e - s] = p[0];
2619 for (i = 0 , p = es->undo_text ; i < e - s ; i++)
2620 p[i] = buf[i];
2621 es->undo_position = s;
2622 } else {
2623 /* new undo-buffer */
2624 EDIT_MakeUndoFit(es, e - s);
2625 memcpy(es->undo_text, buf, (e - s)*sizeof(WCHAR));
2626 es->undo_text[e - s] = 0; /* ensure 0 termination */
2627 es->undo_position = s;
2628 }
2629 /* any deletion makes the old insertion-undo invalid */
2630 es->undo_insert_count = 0;
2631 } else
2632 EDIT_EM_EmptyUndoBuffer(es);
2633 }
2634 if (strl) {
2635 if (can_undo) {
2636 if ((s == es->undo_position) ||
2637 ((es->undo_insert_count) &&
2638 (s == es->undo_position + es->undo_insert_count)))
2639 /*
2640 * insertion is new and at delete position or
2641 * an extension to either left or right
2642 */
2643 es->undo_insert_count += strl;
2644 else {
2645 /* new insertion undo */
2646 es->undo_position = s;
2647 es->undo_insert_count = strl;
2648 /* new insertion makes old delete-buffer invalid */
2649 *es->undo_text = '\0';
2650 }
2651 } else
2652 EDIT_EM_EmptyUndoBuffer(es);
2653 }
2654
2655 heap_free(buf);
2656
2657 s += strl;
2658
2659 /* If text has been deleted and we're right or center aligned then scroll rightward */
2660 if (es->style & (ES_RIGHT | ES_CENTER))
2661 {
2662 INT delta = strl - abs(es->selection_end - es->selection_start);
2663
2664 if (delta < 0 && es->x_offset)
2665 {
2666 if (abs(delta) > es->x_offset)
2667 es->x_offset = 0;
2668 else
2669 es->x_offset += delta;
2670 }
2671 }
2672
2673 EDIT_EM_SetSel(es, s, s, FALSE);
2674 es->flags |= EF_MODIFIED;
2675 if (send_update) es->flags |= EF_UPDATE;
2676 if (hrgn)
2677 {
2678 EDIT_UpdateTextRegion(es, hrgn, TRUE);
2679 DeleteObject(hrgn);
2680 }
2681 else
2682 EDIT_UpdateText(es, NULL, TRUE);
2683
2684 EDIT_EM_ScrollCaret(es);
2685
2686 /* force scroll info update */
2687 EDIT_UpdateScrollInfo(es);
2688
2689
2690 if(send_update || (es->flags & EF_UPDATE))
2691 {
2692 es->flags &= ~EF_UPDATE;
2693 if (!notify_parent(es, EN_CHANGE)) return;
2694 }
2695 EDIT_InvalidateUniscribeData(es);
EF_MODIFIED
#define EF_MODIFIED
Definition: edit.c:65
EDIT_CalcLineWidth_SL
static void EDIT_CalcLineWidth_SL(EDITSTATE *es)
Definition: edit.c:761
EDIT_EM_ScrollCaret
static void EDIT_EM_ScrollCaret(EDITSTATE *es)
Definition: edit.c:1780
EF_UPDATE
#define EF_UPDATE
Definition: edit.c:67
EDIT_InvalidateUniscribeData
static void EDIT_InvalidateUniscribeData(EDITSTATE *es)
Definition: edit.c:315
EDIT_EM_EmptyUndoBuffer
static void EDIT_EM_EmptyUndoBuffer(EDITSTATE *es)
Definition: edit.c:192
text_buffer_changed
static void text_buffer_changed(EDITSTATE *es)
Definition: edit.c:1198
EDIT_MakeFit
static BOOL EDIT_MakeFit(EDITSTATE *es, UINT size)
Definition: edit.c:1276
EDIT_MakeUndoFit
static BOOL EDIT_MakeUndoFit(EDITSTATE *es, UINT size)
Definition: edit.c:1317
EDIT_UpdateTextRegion
static void EDIT_UpdateTextRegion(EDITSTATE *es, HRGN hrgn, BOOL bErase)
Definition: edit.c:1344
EDIT_UpdateText
static void EDIT_UpdateText(EDITSTATE *es, const RECT *rc, BOOL bErase)
Definition: edit.c:1359
EDIT_EM_SetSel
static BOOL EDIT_EM_SetSel(EDITSTATE *es, UINT start, UINT end, BOOL after_wrap)
Definition: edit.c:1489
lstrcpyW
#define lstrcpyW
Definition: compat.h:749
abs
#define abs(i)
Definition: fconv.c:206
p
GLfloat GLfloat p
Definition: glext.h:8902
debugstr_wn
#define debugstr_wn
Definition: kernel32.h:33
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
ES_LOWERCASE
#define ES_LOWERCASE
Definition: pedump.c:669
ES_AUTOVSCROLL
#define ES_AUTOVSCROLL
Definition: pedump.c:671
ES_UPPERCASE
#define ES_UPPERCASE
Definition: pedump.c:668
EN_MAXTEXT
#define EN_MAXTEXT
Definition: winuser.h:2029
CharUpperBuffW
DWORD WINAPI CharUpperBuffW(_Inout_updates_(cchLength) LPWSTR lpsz, _In_ DWORD cchLength)
EN_CHANGE
#define EN_CHANGE
Definition: winuser.h:2025
CharLowerBuffW
DWORD WINAPI CharLowerBuffW(_Inout_updates_(cchLength) LPWSTR lpsz, _In_ DWORD cchLength)

Referenced by EDIT_EM_Undo(), EDIT_GetCompositionStr(), EDIT_GetResultStr(), EDIT_ImeComposition(), EDIT_WindowProc(), EDIT_WM_Char(), EDIT_WM_Clear(), EDIT_WM_Create(), EDIT_WM_Paste(), EDIT_WM_SetText(), and EditWndProc_common().

◆ EDIT_EM_Scroll()

static LRESULT EDIT_EM_Scroll ( EDITSTATE *  es,
INT  action 
)
static

Definition at line 1672 of file edit.c.

1674{
1675 INT dy;
1676
1677 if (!(es->style & ES_MULTILINE))
1678 return (LRESULT)FALSE;
1679
1680 dy = 0;
1681
1682 switch (action) {
1683 case SB_LINEUP:
1684 if (es->y_offset)
1685 dy = -1;
1686 break;
1687 case SB_LINEDOWN:
1688 if (es->y_offset < es->line_count - 1)
1689 dy = 1;
1690 break;
1691 case SB_PAGEUP:
1692 if (es->y_offset)
1693 dy = -(es->format_rect.bottom - es->format_rect.top) / es->line_height;
1694 break;
1695 case SB_PAGEDOWN:
1696 if (es->y_offset < es->line_count - 1)
1697 dy = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
1698 break;
1699 default:
1700 return (LRESULT)FALSE;
1701 }
1702 if (dy) {
1703 INT vlc = get_vertical_line_count(es);
1704 /* check if we are going to move too far */
1705 if(es->y_offset + dy > es->line_count - vlc)
1706 dy = max(es->line_count - vlc, 0) - es->y_offset;
1707
1708 /* Notification is done in EDIT_EM_LineScroll */
1709 if(dy) {
1710 EDIT_EM_LineScroll(es, 0, dy);
1711 return MAKELONG(dy, TRUE);
1712 }
1713
1714 }
1715 return (LRESULT)FALSE;
return
return
Definition: dirsup.c:529
EDIT_EM_LineScroll
static BOOL EDIT_EM_LineScroll(EDITSTATE *es, INT dx, INT dy)
Definition: edit.c:1657
LRESULT
LONG_PTR LRESULT
Definition: windef.h:209
SB_LINEUP
#define SB_LINEUP
Definition: winuser.h:564
SB_PAGEDOWN
#define SB_PAGEDOWN
Definition: winuser.h:569
SB_LINEDOWN
#define SB_LINEDOWN
Definition: winuser.h:565
SB_PAGEUP
#define SB_PAGEUP
Definition: winuser.h:568

Referenced by EDIT_WindowProc(), EDIT_WM_VScroll(), and EditWndProc_common().

◆ EDIT_EM_ScrollCaret()

static void EDIT_EM_ScrollCaret ( EDITSTATE *  es)
static

Definition at line 1780 of file edit.c.

1782{
1783 if (es->style & ES_MULTILINE) {
1784 INT l;
1785 INT vlc;
1786 INT ww;
1787 INT cw = es->char_width;
1788 INT x;
1789 INT dy = 0;
1790 INT dx = 0;
1791
1792 l = EDIT_EM_LineFromChar(es, es->selection_end);
1793 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, es->flags & EF_AFTER_WRAP));
1794 vlc = get_vertical_line_count(es);
1795 if (l >= es->y_offset + vlc)
1796 dy = l - vlc + 1 - es->y_offset;
1797 if (l < es->y_offset)
1798 dy = l - es->y_offset;
1799 ww = es->format_rect.right - es->format_rect.left;
1800 if (x < es->format_rect.left)
1801 dx = x - es->format_rect.left - ww / HSCROLL_FRACTION / cw * cw;
1802 if (x > es->format_rect.right)
1803 dx = x - es->format_rect.left - (HSCROLL_FRACTION - 1) * ww / HSCROLL_FRACTION / cw * cw;
1804 if (dy || dx || (es->y_offset && (es->line_count - es->y_offset < vlc)))
1805 {
1806 /* check if we are going to move too far */
1807 if(es->x_offset + dx + ww > es->text_width)
1808 dx = es->text_width - ww - es->x_offset;
1809 if(dx || dy || (es->y_offset && (es->line_count - es->y_offset < vlc)))
1810 EDIT_EM_LineScroll_internal(es, dx, dy);
1811 }
1812 } else {
1813 INT x;
1814 INT goal;
1815 INT format_width;
1816
1817 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, FALSE));
1818 format_width = es->format_rect.right - es->format_rect.left;
1819 if (x < es->format_rect.left) {
1820 goal = es->format_rect.left + format_width / HSCROLL_FRACTION;
1821 do {
1822 es->x_offset--;
1823 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, FALSE));
1824 } while ((x < goal) && es->x_offset);
1825 /* FIXME: use ScrollWindow() somehow to improve performance */
1826 EDIT_UpdateText(es, NULL, TRUE);
1827 } else if (x > es->format_rect.right) {
1828 INT x_last;
1829 INT len = get_text_length(es);
1830 goal = es->format_rect.right - format_width / HSCROLL_FRACTION;
1831 do {
1832 es->x_offset++;
1833 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, FALSE));
1834 x_last = (short)LOWORD(EDIT_EM_PosFromChar(es, len, FALSE));
1835 } while ((x > goal) && (x_last > es->format_rect.right));
1836 /* FIXME: use ScrollWindow() somehow to improve performance */
1837 EDIT_UpdateText(es, NULL, TRUE);
1838 }
1839 }
1840
1841 EDIT_SetCaretPos(es, es->selection_end, es->flags & EF_AFTER_WRAP);
HSCROLL_FRACTION
#define HSCROLL_FRACTION
Definition: edit.c:60

Referenced by EDIT_EM_ReplaceSel(), EDIT_EM_SetHandle(), EDIT_EM_Undo(), EDIT_MoveBackward(), EDIT_MoveDown_ML(), EDIT_MoveEnd(), EDIT_MoveForward(), EDIT_MoveHome(), EDIT_MovePageDown_ML(), EDIT_MovePageUp_ML(), EDIT_MoveUp_ML(), EDIT_MoveWordBackward(), EDIT_MoveWordForward(), EDIT_WindowProc(), EDIT_WM_Create(), EDIT_WM_LButtonDblClk(), EDIT_WM_LButtonDown(), EDIT_WM_SetText(), and EditWndProc_common().

◆ EDIT_EM_SetCueBanner()

static BOOL EDIT_EM_SetCueBanner ( EDITSTATE *  es,
BOOL  draw_focused,
const WCHAR *  cue_text 
)
static

Definition at line 4325 of file edit.c.

4327{
4328 if (es->style & ES_MULTILINE || !cue_text)
4329 return FALSE;
4330
4331 heap_free(es->cue_banner_text);
4332 es->cue_banner_text = heap_strdupW(cue_text);
4333 es->cue_banner_draw_focused = draw_focused;
4334
4335 return TRUE;
heap_strdupW
static WCHAR * heap_strdupW(const WCHAR *str)
Definition: edit.c:4312

Referenced by EDIT_WindowProc().

◆ EDIT_EM_SetHandle()

static void EDIT_EM_SetHandle ( EDITSTATE *  es,
HLOCAL  hloc 
)
static

Definition at line 2705 of file edit.c.

2707{
2708 if (!(es->style & ES_MULTILINE))
2709 return;
2710
2711 if (!hloc)
2712 return;
2713
2714 EDIT_UnlockBuffer(es, TRUE);
2715
2716 es->hloc32W = hloc;
2717 es->buffer_size = LocalSize(es->hloc32W)/sizeof(WCHAR) - 1;
2718
2719 /* The text buffer handle belongs to the control */
2720 es->hlocapp = NULL;
2721
2722 EDIT_LockBuffer(es);
2723 text_buffer_changed(es);
2724
2725 es->x_offset = es->y_offset = 0;
2726 es->selection_start = es->selection_end = 0;
2727 EDIT_EM_EmptyUndoBuffer(es);
2728 es->flags &= ~EF_MODIFIED;
2729 es->flags &= ~EF_UPDATE;
2730 EDIT_BuildLineDefs_ML(es, 0, get_text_length(es), 0, NULL);
2731 EDIT_UpdateText(es, NULL, TRUE);
2732 EDIT_EM_ScrollCaret(es);
2733 /* force scroll info update */
2734 EDIT_UpdateScrollInfo(es);
EDIT_LockBuffer
static void EDIT_LockBuffer(EDITSTATE *es)
Definition: edit.c:1211

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetLimitText()

static void EDIT_EM_SetLimitText ( EDITSTATE *  es,
UINT  limit 
)
static

Definition at line 2744 of file edit.c.

2746{
2747 if (!limit) limit = ~0u;
2748 if (!(es->style & ES_MULTILINE)) limit = min(limit, 0x7ffffffe);
2749 es->buffer_limit = limit;
limit
GLint limit
Definition: glext.h:10326
u
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetMargins()

static void EDIT_EM_SetMargins ( EDITSTATE *  es,
INT  action,
WORD  left,
WORD  right,
BOOL  repaint 
)
static

Definition at line 2794 of file edit.c.

2797{
2798 TEXTMETRICW tm;
2799 INT default_left_margin = 0; /* in pixels */
2800 INT default_right_margin = 0; /* in pixels */
2801
2802 /* Set the default margins depending on the font */
2803 if (es->font && (left == EC_USEFONTINFO || right == EC_USEFONTINFO)) {
2804 HDC dc = GetDC(es->hwndSelf);
2805 HFONT old_font = SelectObject(dc, es->font);
2806 LONG width = GdiGetCharDimensions(dc, &tm, NULL), rc_width;
2807 RECT rc;
2808
2809 /* The default margins are only non zero for TrueType or Vector fonts */
2810 if (tm.tmPitchAndFamily & ( TMPF_VECTOR | TMPF_TRUETYPE )) {
2811 struct char_width_info width_info;
2812
2813 if (is_cjk(dc) && GetCharWidthInfo(dc, &width_info))
2814 {
2815 default_left_margin = get_cjk_fontinfo_margin(width, width_info.min_lsb);
2816 default_right_margin = get_cjk_fontinfo_margin(width, width_info.min_rsb);
2817 }
2818 else
2819 {
2820 default_left_margin = width / 2;
2821 default_right_margin = width / 2;
2822 }
2823
2824 GetClientRect(es->hwndSelf, &rc);
2825 rc_width = !IsRectEmpty(&rc) ? rc.right - rc.left : 80;
2826 if (rc_width < default_left_margin + default_right_margin + width * 2) {
2827 default_left_margin = es->left_margin;
2828 default_right_margin = es->right_margin;
2829 }
2830 }
2831 SelectObject(dc, old_font);
2832 ReleaseDC(es->hwndSelf, dc);
2833 }
2834
2835 if (action & EC_LEFTMARGIN) {
2836 es->format_rect.left -= es->left_margin;
2837 if (left != EC_USEFONTINFO)
2838 es->left_margin = left;
2839 else
2840 es->left_margin = default_left_margin;
2841 es->format_rect.left += es->left_margin;
2842 }
2843
2844 if (action & EC_RIGHTMARGIN) {
2845 es->format_rect.right += es->right_margin;
2846 if (right != EC_USEFONTINFO)
2847 es->right_margin = right;
2848 else
2849 es->right_margin = default_right_margin;
2850 es->format_rect.right -= es->right_margin;
2851 }
2852
2853 if (action & (EC_LEFTMARGIN | EC_RIGHTMARGIN)) {
2854 EDIT_AdjustFormatRect(es);
2855 if (repaint) EDIT_UpdateText(es, NULL, TRUE);
2856 }
2857
2858 TRACE("left=%d, right=%d\n", es->left_margin, es->right_margin);
GetCharWidthInfo
BOOL WINAPI GetCharWidthInfo(HDC, struct char_width_info *)
EDIT_AdjustFormatRect
static void EDIT_AdjustFormatRect(EDITSTATE *es)
Definition: edit.c:2268
get_cjk_fontinfo_margin
static int get_cjk_fontinfo_margin(int width, int side_bearing)
Definition: edit.c:2765
width
GLint GLint GLsizei width
Definition: gl.h:1546
right
GLdouble GLdouble right
Definition: glext.h:10859
left
GLint left
Definition: glext.h:7726
dc
static const WCHAR dc[]
Definition: metadataquery.c:790
HDC
static HDC
Definition: imagelist.c:88
HFONT
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
is_cjk
static BOOL is_cjk(void)
Definition: dde.c:46
LONG
long LONG
Definition: pedump.c:60
char_width_info
Definition: edit.c:2775
tm
Definition: time.h:68
GdiGetCharDimensions
LONG WINAPI GdiGetCharDimensions(HDC, LPTEXTMETRICW, LONG *)
Definition: font.c:2145
SelectObject
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1546
TMPF_TRUETYPE
#define TMPF_TRUETYPE
Definition: wingdi.h:1313
TMPF_VECTOR
#define TMPF_VECTOR
Definition: wingdi.h:1312
ReleaseDC
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
EC_RIGHTMARGIN
#define EC_RIGHTMARGIN
Definition: winuser.h:2610
EC_USEFONTINFO
#define EC_USEFONTINFO
Definition: winuser.h:2611
IsRectEmpty
BOOL WINAPI IsRectEmpty(_In_ LPCRECT)
GetDC
HDC WINAPI GetDC(_In_opt_ HWND)
EC_LEFTMARGIN
#define EC_LEFTMARGIN
Definition: winuser.h:2609

Referenced by EDIT_WindowProc(), and EDIT_WM_SetFont().

◆ EDIT_EM_SetPasswordChar()

static void EDIT_EM_SetPasswordChar ( EDITSTATE *  es,
WCHAR  c 
)
static

Definition at line 2866 of file edit.c.

2868{
2869 LONG style;
2870
2871 if (es->style & ES_MULTILINE)
2872 return;
2873
2874 if (es->password_char == c)
2875 return;
2876
2877 style = GetWindowLongW( es->hwndSelf, GWL_STYLE );
2878 es->password_char = c;
2879 if (c) {
2880 SetWindowLongW( es->hwndSelf, GWL_STYLE, style | ES_PASSWORD );
2881 es->style |= ES_PASSWORD;
2882 } else {
2883 SetWindowLongW( es->hwndSelf, GWL_STYLE, style & ~ES_PASSWORD );
2884 es->style &= ~ES_PASSWORD;
2885 }
2886 EDIT_InvalidateUniscribeData(es);
2887 EDIT_UpdateText(es, NULL, TRUE);
style
Arabic default style
Definition: afstyles.h:94
c
const GLubyte * c
Definition: glext.h:8905
c
#define c
Definition: ke_i.h:80
ES_PASSWORD
#define ES_PASSWORD
Definition: pedump.c:670
SetWindowLongW
LONG WINAPI SetWindowLongW(_In_ HWND, _In_ int, _In_ LONG)
GetWindowLongW
LONG WINAPI GetWindowLongW(_In_ HWND, _In_ int)
GWL_STYLE
#define GWL_STYLE
Definition: winuser.h:855

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetSel()

static BOOL EDIT_EM_SetSel ( EDITSTATE *  es,
UINT  start,
UINT  end,
BOOL  after_wrap 
)
static

Definition at line 1489 of file edit.c.

1491{
1492 UINT old_start = es->selection_start;
1493 UINT old_end = es->selection_end;
1494 UINT len = get_text_length(es);
1495
1496 if (start == old_start && end == old_end)
1497 return FALSE;
1498
1499 if (start == (UINT)-1) {
1500 start = es->selection_end;
1501 end = es->selection_end;
1502 } else {
1503 start = min(start, len);
1504 end = min(end, len);
1505 }
1506 es->selection_start = start;
1507 es->selection_end = end;
1508 if (after_wrap)
1509 es->flags |= EF_AFTER_WRAP;
1510 else
1511 es->flags &= ~EF_AFTER_WRAP;
1512 /* Compute the necessary invalidation region. */
1513 /* Note that we don't need to invalidate regions which have
1514 * "never" been selected, or those which are "still" selected.
1515 * In fact, every time we hit a selection boundary, we can
1516 * *toggle* whether we need to invalidate. Thus we can optimize by
1517 * *sorting* the interval endpoints. Let's assume that we sort them
1518 * in this order:
1519 * start <= end <= old_start <= old_end
1520 * Knuth 5.3.1 (p 183) assures us that this can be done optimally
1521 * in 5 comparisons; i.e. it is impossible to do better than the
1522 * following: */
1523 ORDER_UINT(end, old_end);
1524 ORDER_UINT(start, old_start);
1525 ORDER_UINT(old_start, old_end);
1526 ORDER_UINT(start, end);
1527 /* Note that at this point 'end' and 'old_start' are not in order, but
1528 * start is definitely the min. and old_end is definitely the max. */
1529 if (end != old_start)
1530 {
1531/*
1532 * One can also do
1533 * ORDER_UINT32(end, old_start);
1534 * EDIT_InvalidateText(es, start, end);
1535 * EDIT_InvalidateText(es, old_start, old_end);
1536 * in place of the following if statement.
1537 * (That would complete the optimal five-comparison four-element sort.)
1538 */
1539 if (old_start > end )
1540 {
1541 EDIT_InvalidateText(es, start, end);
1542 EDIT_InvalidateText(es, old_start, old_end);
1543 }
1544 else
1545 {
1546 EDIT_InvalidateText(es, start, old_start);
1547 EDIT_InvalidateText(es, end, old_end);
1548 }
1549 }
1550 else EDIT_InvalidateText(es, start, old_end);
1551
1552 return TRUE;
EDIT_InvalidateText
static void EDIT_InvalidateText(EDITSTATE *es, INT start, INT end)
Definition: edit.c:1459

Referenced by EDIT_EM_ReplaceSel(), EDIT_EM_Undo(), EDIT_MoveBackward(), EDIT_MoveDown_ML(), EDIT_MoveEnd(), EDIT_MoveForward(), EDIT_MoveHome(), EDIT_MovePageDown_ML(), EDIT_MovePageUp_ML(), EDIT_MoveUp_ML(), EDIT_MoveWordBackward(), EDIT_MoveWordForward(), EDIT_WindowProc(), EDIT_WM_Char(), EDIT_WM_KeyDown(), EDIT_WM_LButtonDblClk(), EDIT_WM_LButtonDown(), EDIT_WM_MouseMove(), EDIT_WM_SetText(), and EditWndProc_common().

◆ EDIT_EM_SetTabStops()

static BOOL EDIT_EM_SetTabStops ( EDITSTATE *  es,
INT  count,
const INT *  tabs 
)
static

Definition at line 2895 of file edit.c.

2897{
2898 if (!(es->style & ES_MULTILINE))
2899 return FALSE;
2900 heap_free(es->tabs);
2901 es->tabs_count = count;
2902 if (!count)
2903 es->tabs = NULL;
2904 else {
2905 es->tabs = heap_alloc(count * sizeof(INT));
2906 memcpy(es->tabs, tabs, count * sizeof(INT));
2907 }
2908 EDIT_InvalidateUniscribeData(es);
2909 return TRUE;

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetWordBreakProc()

static void EDIT_EM_SetWordBreakProc ( EDITSTATE *  es,
EDITWORDBREAKPROCW  wbp 
)
static

Definition at line 2917 of file edit.c.

2919{
2920 if (es->word_break_proc == wbp)
2921 return;
2922
2923 es->word_break_proc = wbp;
2924
2925 if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL)) {
2926 EDIT_BuildLineDefs_ML(es, 0, get_text_length(es), 0, NULL);
2927 EDIT_UpdateText(es, NULL, TRUE);
2928 }

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_Undo()

static BOOL EDIT_EM_Undo ( EDITSTATE *  es)
static

Definition at line 2936 of file edit.c.

2938{
2939 INT ulength;
2940 LPWSTR utext;
2941
2942 /* As per MSDN spec, for a single-line edit control,
2943 the return value is always TRUE */
2944 if( es->style & ES_READONLY )
2945 return !(es->style & ES_MULTILINE);
2946
2947 ulength = lstrlenW(es->undo_text);
2948
2949 utext = heap_alloc((ulength + 1) * sizeof(WCHAR));
2950
2951 lstrcpyW(utext, es->undo_text);
2952
2953 TRACE("before UNDO:insertion length = %d, deletion buffer = %s\n",
2954 es->undo_insert_count, debugstr_w(utext));
2955
2956 EDIT_EM_SetSel(es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
2957 EDIT_EM_EmptyUndoBuffer(es);
2958 EDIT_EM_ReplaceSel(es, TRUE, utext, ulength, TRUE, TRUE);
2959 EDIT_EM_SetSel(es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
2960 /* send the notification after the selection start and end are set */
2961 if (!notify_parent(es, EN_CHANGE)) return TRUE;
2962 EDIT_EM_ScrollCaret(es);
2963 heap_free(utext);
2964
2965 TRACE("after UNDO:insertion length = %d, deletion buffer = %s\n",
2966 es->undo_insert_count, debugstr_w(es->undo_text));
2967 return TRUE;
EDIT_EM_ReplaceSel
static void EDIT_EM_ReplaceSel(EDITSTATE *es, BOOL can_undo, const WCHAR *lpsz_replace, UINT strl, BOOL send_update, BOOL honor_limit)
Definition: edit.c:2492
ES_READONLY
#define ES_READONLY
Definition: pedump.c:675

Referenced by EDIT_WindowProc(), EDIT_WM_SysKeyDown(), and EditWndProc_common().

◆ EDIT_GetCompositionStr()

static void EDIT_GetCompositionStr ( HIMC  hIMC,
LPARAM  CompFlag,
EDITSTATE *  es 
)
static

Definition at line 4367 of file edit.c.

4369{
4370 LONG buflen;
4371 LPWSTR lpCompStr;
4372 LPSTR lpCompStrAttr = NULL;
4373 DWORD dwBufLenAttr;
4374
4375 buflen = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0);
4376
4377 if (buflen < 0)
4378 {
4379 return;
4380 }
4381
4382 lpCompStr = heap_alloc(buflen);
4383 if (!lpCompStr)
4384 {
4385 ERR("Unable to allocate IME CompositionString\n");
4386 return;
4387 }
4388
4389 if (buflen)
4390 ImmGetCompositionStringW(hIMC, GCS_COMPSTR, lpCompStr, buflen);
4391
4392 if (CompFlag & GCS_COMPATTR)
4393 {
4394 /*
4395 * We do not use the attributes yet. it would tell us what characters
4396 * are in transition and which are converted or decided upon
4397 */
4398 dwBufLenAttr = ImmGetCompositionStringW(hIMC, GCS_COMPATTR, NULL, 0);
4399 if (dwBufLenAttr)
4400 {
4401 dwBufLenAttr ++;
4402 lpCompStrAttr = heap_alloc(dwBufLenAttr + 1);
4403 if (!lpCompStrAttr)
4404 {
4405 ERR("Unable to allocate IME Attribute String\n");
4406 heap_free(lpCompStr);
4407 return;
4408 }
4409 ImmGetCompositionStringW(hIMC,GCS_COMPATTR, lpCompStrAttr,
4410 dwBufLenAttr);
4411 lpCompStrAttr[dwBufLenAttr] = 0;
4412 }
4413 }
4414
4415#ifndef __REACTOS__ /* We don't use internal composition string. Rely on the composition window */
4416 /* check for change in composition start */
4417 if (es->selection_end < es->composition_start)
4418 es->composition_start = es->selection_end;
4419
4420 /* replace existing selection string */
4421 es->selection_start = es->composition_start;
4422
4423 if (es->composition_len > 0)
4424 es->selection_end = es->composition_start + es->composition_len;
4425 else
4426 es->selection_end = es->selection_start;
4427
4428 EDIT_EM_ReplaceSel(es, FALSE, lpCompStr, buflen / sizeof(WCHAR), TRUE, TRUE);
4429 es->composition_len = abs(es->composition_start - es->selection_end);
4430
4431 es->selection_start = es->composition_start;
4432 es->selection_end = es->selection_start + es->composition_len;
4433#endif
4434
4435 heap_free(lpCompStrAttr);
4436 heap_free(lpCompStr);
ImmGetCompositionStringW
LONG WINAPI ImmGetCompositionStringW(HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)
Definition: compstr.c:899
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
GCS_COMPATTR
#define GCS_COMPATTR
Definition: imm.h:228
GCS_COMPSTR
#define GCS_COMPSTR
Definition: imm.h:227
LPSTR
char * LPSTR
Definition: xmlstorage.h:182

Referenced by EDIT_ImeComposition().

◆ EDIT_GetLineRect()

static void EDIT_GetLineRect ( EDITSTATE *  es,
INT  line,
INT  scol,
INT  ecol,
LPRECT  rc 
)
static

Definition at line 1147 of file edit.c.

1149{
1150 SCRIPT_STRING_ANALYSIS ssa;
1151 INT line_index = 0;
1152 INT pt1, pt2, pt3;
1153
1154 if (es->style & ES_MULTILINE)
1155 {
1156 const LINEDEF *line_def = NULL;
1157 rc->top = es->format_rect.top + (line - es->y_offset) * es->line_height;
1158 if (line >= es->line_count)
1159 return;
1160
1161 line_def = es->first_line_def;
1162 if (line == -1) {
1163 INT index = es->selection_end - line_def->length;
1164 while ((index >= 0) && line_def->next) {
1165 line_index += line_def->length;
1166 line_def = line_def->next;
1167 index -= line_def->length;
1168 }
1169 } else {
1170 while (line > 0) {
1171 line_index += line_def->length;
1172 line_def = line_def->next;
1173 line--;
1174 }
1175 }
1176 ssa = line_def->ssa;
1177 }
1178 else
1179 {
1180 line_index = 0;
1181 rc->top = es->format_rect.top;
1182 ssa = es->ssa;
1183 }
1184
1185 rc->bottom = rc->top + es->line_height;
1186 pt1 = (scol == 0) ? es->format_rect.left : (short)LOWORD(EDIT_EM_PosFromChar(es, line_index + scol, TRUE));
1187 pt2 = (ecol == -1) ? es->format_rect.right : (short)LOWORD(EDIT_EM_PosFromChar(es, line_index + ecol, TRUE));
1188 if (ssa)
1189 {
1190 ScriptStringCPtoX(ssa, scol, FALSE, &pt3);
1191 pt3+=es->format_rect.left;
1192 }
1193 else pt3 = pt1;
1194 rc->right = max(max(pt1 , pt2),pt3);
1195 rc->left = min(min(pt1, pt2),pt3);

Referenced by EDIT_ML_InvalidateText(), EDIT_SL_InvalidateText(), and EDIT_WM_Paint().

◆ EDIT_GetResultStr()

static void EDIT_GetResultStr ( HIMC  hIMC,
EDITSTATE *  es 
)
static

Definition at line 4438 of file edit.c.

4440{
4441 LONG buflen;
4442 LPWSTR lpResultStr;
4443
4444 buflen = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
4445 if (buflen <= 0)
4446 {
4447 return;
4448 }
4449
4450 lpResultStr = heap_alloc(buflen);
4451 if (!lpResultStr)
4452 {
4453 ERR("Unable to alloc buffer for IME string\n");
4454 return;
4455 }
4456
4457 ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, lpResultStr, buflen);
4458
4459#ifndef __REACTOS__
4460 /* check for change in composition start */
4461 if (es->selection_end < es->composition_start)
4462 es->composition_start = es->selection_end;
4463
4464 es->selection_start = es->composition_start;
4465 es->selection_end = es->composition_start + es->composition_len;
4466 EDIT_EM_ReplaceSel(es, TRUE, lpResultStr, buflen / sizeof(WCHAR), TRUE, TRUE);
4467 es->composition_start = es->selection_end;
4468 es->composition_len = 0;
4469#endif
4470
4471 heap_free(lpResultStr);
GCS_RESULTSTR
#define GCS_RESULTSTR
Definition: imm.h:234

Referenced by EDIT_ImeComposition().

◆ EDIT_ImeComposition()

static void EDIT_ImeComposition ( HWND  hwnd,
LPARAM  CompFlag,
EDITSTATE *  es 
)
static

Definition at line 4473 of file edit.c.

4475{
4476 HIMC hIMC;
4477 int cursor;
4478
4479#ifdef __REACTOS__
4480 if (es->selection_start != es->selection_end)
4481 EDIT_EM_ReplaceSel(es, TRUE, NULL, 0, TRUE, TRUE);
4482#else
4483 if (es->composition_len == 0 && es->selection_start != es->selection_end)
4484 {
4485 EDIT_EM_ReplaceSel(es, TRUE, NULL, 0, TRUE, TRUE);
4486 es->composition_start = es->selection_end;
4487 }
4488#endif
4489
4490 hIMC = ImmGetContext(hwnd);
4491 if (!hIMC)
4492 return;
4493
4494 if (CompFlag & GCS_RESULTSTR)
4495 {
4496 EDIT_GetResultStr(hIMC, es);
4497 cursor = 0;
4498 }
4499 else
4500 {
4501 if (CompFlag & GCS_COMPSTR)
4502 EDIT_GetCompositionStr(hIMC, CompFlag, es);
4503#ifdef __REACTOS__
4504 cursor = 0;
4505#else
4506 cursor = ImmGetCompositionStringW(hIMC, GCS_CURSORPOS, 0, 0);
4507#endif
4508 }
4509 ImmReleaseContext(hwnd, hIMC);
4510 EDIT_SetCaretPos(es, es->selection_start + cursor, es->flags & EF_AFTER_WRAP);
HIMC
DWORD HIMC
Definition: dimm.idl:75
EDIT_GetResultStr
static void EDIT_GetResultStr(HIMC hIMC, EDITSTATE *es)
Definition: edit.c:4438
EDIT_GetCompositionStr
static void EDIT_GetCompositionStr(HIMC hIMC, LPARAM CompFlag, EDITSTATE *es)
Definition: edit.c:4367
ImmGetContext
HIMC WINAPI ImmGetContext(HWND hWnd)
Definition: imm.c:1045
ImmReleaseContext
BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
Definition: imm.c:1086
cursor
const char cursor[]
Definition: icontest.c:13
GCS_CURSORPOS
#define GCS_CURSORPOS
Definition: imm.h:230
hwnd
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

Referenced by EDIT_WindowProc().

◆ EDIT_InvalidateText()

static void EDIT_InvalidateText ( EDITSTATE *  es,
INT  start,
INT  end 
)
static

Definition at line 1459 of file edit.c.

1461{
1462 if (end == start)
1463 return;
1464
1465 if (end == -1)
1466 end = get_text_length(es);
1467
1468 if (end < start) {
1469 INT tmp = start;
1470 start = end;
1471 end = tmp;
1472 }
1473
1474 if (es->style & ES_MULTILINE)
1475 EDIT_ML_InvalidateText(es, start, end);
1476 else
1477 EDIT_SL_InvalidateText(es, start, end);
EDIT_ML_InvalidateText
static void EDIT_ML_InvalidateText(EDITSTATE *es, INT start, INT end)
Definition: edit.c:1394
EDIT_SL_InvalidateText
static void EDIT_SL_InvalidateText(EDITSTATE *es, INT start, INT end)
Definition: edit.c:1376

Referenced by EDIT_EM_SetSel(), EDIT_WM_KillFocus(), and EDIT_WM_SetFocus().

◆ EDIT_InvalidateUniscribeData()

static void EDIT_InvalidateUniscribeData ( EDITSTATE *  es)
inlinestatic

Definition at line 315 of file edit.c.

317{
318 LINEDEF *line_def = es->first_line_def;
319 while (line_def)
320 {
321 EDIT_InvalidateUniscribeData_linedef(line_def);
322 line_def = line_def->next;
323 }
324 if (es->ssa)
325 {
326 ScriptStringFree(&es->ssa);
327 es->ssa = NULL;
328 }
ScriptStringFree
HRESULT WINAPI ScriptStringFree(SCRIPT_STRING_ANALYSIS *pssa)
Definition: usp10.c:2556

Referenced by EDIT_EM_ReplaceSel(), EDIT_EM_SetPasswordChar(), EDIT_EM_SetTabStops(), EDIT_WM_NCCreate(), EDIT_WM_NCDestroy(), EDIT_WM_Paint(), EDIT_WM_SetFont(), EDIT_WM_SetText(), and text_buffer_changed().

◆ EDIT_InvalidateUniscribeData_linedef()

static void EDIT_InvalidateUniscribeData_linedef ( LINEDEF *  line_def)
inlinestatic

Definition at line 306 of file edit.c.

308{
309 if (line_def->ssa)
310 {
311 ScriptStringFree(&line_def->ssa);
312 line_def->ssa = NULL;
313 }

Referenced by EDIT_BuildLineDefs_ML(), and EDIT_InvalidateUniscribeData().

◆ EDIT_IsInsideDialog()

static BOOL EDIT_IsInsideDialog ( EDITSTATE *  es)
inlinestatic

Definition at line 2977 of file edit.c.

2979{
2980 return (es->flags & EF_DIALOGMODE);
EF_DIALOGMODE
#define EF_DIALOGMODE
Definition: edit.c:72

Referenced by EDIT_WM_Char(), and EDIT_WM_KeyDown().

◆ EDIT_LockBuffer()

static void EDIT_LockBuffer ( EDITSTATE *  es)
static

Definition at line 1211 of file edit.c.

1213{
1214 if (!es->text)
1215 {
1216 if (!es->hloc32W)
1217 return;
1218
1219 es->text = LocalLock(es->hloc32W);
1220 }
1221
1222 es->lock_count++;
LocalLock
LPVOID NTAPI LocalLock(HLOCAL hMem)
Definition: heapmem.c:1616

Referenced by EDIT_EM_SetHandle(), EDIT_MakeFit(), EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_MakeFit()

static BOOL EDIT_MakeFit ( EDITSTATE *  es,
UINT  size 
)
static

Definition at line 1276 of file edit.c.

1278{
1279 HLOCAL hNew32W;
1280
1281 if (size <= es->buffer_size)
1282 return TRUE;
1283
1284 TRACE("trying to ReAlloc to %d+1 characters\n", size);
1285
1286 /* Force edit to unlock its buffer. es->text now NULL */
1287 EDIT_UnlockBuffer(es, TRUE);
1288
1289 if (es->hloc32W) {
1290 UINT alloc_size = ROUND_TO_GROW((size + 1) * sizeof(WCHAR));
1291 if ((hNew32W = LocalReAlloc(es->hloc32W, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT))) {
1292 TRACE("Old 32 bit handle %p, new handle %p\n", es->hloc32W, hNew32W);
1293 es->hloc32W = hNew32W;
1294 es->buffer_size = LocalSize(hNew32W)/sizeof(WCHAR) - 1;
1295 }
1296 }
1297
1298 EDIT_LockBuffer(es);
1299
1300 if (es->buffer_size < size) {
1301 WARN("FAILED ! We now have %d+1\n", es->buffer_size);
1302 notify_parent(es, EN_ERRSPACE);
1303 return FALSE;
1304 } else {
1305 TRACE("We now have %d+1\n", es->buffer_size);
1306 return TRUE;
1307 }
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
ROUND_TO_GROW
#define ROUND_TO_GROW(size)
Definition: edit.c:59
LocalReAlloc
HLOCAL NTAPI LocalReAlloc(HLOCAL hMem, SIZE_T dwBytes, UINT uFlags)
Definition: heapmem.c:1625
buffer_size
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:888
LMEM_MOVEABLE
#define LMEM_MOVEABLE
Definition: winbase.h:395
LMEM_ZEROINIT
#define LMEM_ZEROINIT
Definition: winbase.h:401
EN_ERRSPACE
#define EN_ERRSPACE
Definition: winuser.h:2026

Referenced by EDIT_EM_ReplaceSel().

◆ EDIT_MakeUndoFit()

static BOOL EDIT_MakeUndoFit ( EDITSTATE *  es,
UINT  size 
)
static

Definition at line 1317 of file edit.c.

1319{
1320 UINT alloc_size;
1321
1322 if (size <= es->undo_buffer_size)
1323 return TRUE;
1324
1325 TRACE("trying to ReAlloc to %d+1\n", size);
1326
1327 alloc_size = ROUND_TO_GROW((size + 1) * sizeof(WCHAR));
1328 if ((es->undo_text = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, es->undo_text, alloc_size))) {
1329 es->undo_buffer_size = alloc_size/sizeof(WCHAR) - 1;
1330 return TRUE;
1331 }
1332 else
1333 {
1334 WARN("FAILED ! We now have %d+1\n", es->undo_buffer_size);
1335 return FALSE;
1336 }
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
HeapReAlloc
#define HeapReAlloc
Definition: compat.h:734
HEAP_ZERO_MEMORY
#define HEAP_ZERO_MEMORY
Definition: compat.h:134

Referenced by EDIT_EM_ReplaceSel().

◆ EDIT_ML_InvalidateText()

static void EDIT_ML_InvalidateText ( EDITSTATE *  es,
INT  start,
INT  end 
)
static

Definition at line 1394 of file edit.c.

1396{
1397 INT vlc = get_vertical_line_count(es);
1398 INT sl = EDIT_EM_LineFromChar(es, start);
1399 INT el = EDIT_EM_LineFromChar(es, end);
1400 INT sc;
1401 INT ec;
1402 RECT rc1;
1403 RECT rcWnd;
1404 RECT rcLine;
1405 RECT rcUpdate;
1406 INT l;
1407
1408 if ((el < es->y_offset) || (sl > es->y_offset + vlc))
1409 return;
1410
1411 sc = start - EDIT_EM_LineIndex(es, sl);
1412 ec = end - EDIT_EM_LineIndex(es, el);
1413 if (sl < es->y_offset) {
1414 sl = es->y_offset;
1415 sc = 0;
1416 }
1417 if (el > es->y_offset + vlc) {
1418 el = es->y_offset + vlc;
1419 ec = EDIT_EM_LineLength(es, EDIT_EM_LineIndex(es, el));
1420 }
1421 GetClientRect(es->hwndSelf, &rc1);
1422 IntersectRect(&rcWnd, &rc1, &es->format_rect);
1423 if (sl == el) {
1424 EDIT_GetLineRect(es, sl, sc, ec, &rcLine);
1425 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1426 EDIT_UpdateText(es, &rcUpdate, TRUE);
1427 } else {
1428 EDIT_GetLineRect(es, sl, sc,
1429 EDIT_EM_LineLength(es,
1430 EDIT_EM_LineIndex(es, sl)),
1431 &rcLine);
1432 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1433 EDIT_UpdateText(es, &rcUpdate, TRUE);
1434 for (l = sl + 1 ; l < el ; l++) {
1435 EDIT_GetLineRect(es, l, 0,
1436 EDIT_EM_LineLength(es,
1437 EDIT_EM_LineIndex(es, l)),
1438 &rcLine);
1439 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1440 EDIT_UpdateText(es, &rcUpdate, TRUE);
1441 }
1442 EDIT_GetLineRect(es, el, 0, ec, &rcLine);
1443 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1444 EDIT_UpdateText(es, &rcUpdate, TRUE);
1445 }
EDIT_GetLineRect
static void EDIT_GetLineRect(EDITSTATE *es, INT line, INT scol, INT ecol, LPRECT rc)
Definition: edit.c:1147

Referenced by EDIT_InvalidateText().

◆ EDIT_MoveBackward()

static void EDIT_MoveBackward ( EDITSTATE *  es,
BOOL  extend 
)
static

Definition at line 1849 of file edit.c.

1851{
1852 INT e = es->selection_end;
1853
1854 if (e) {
1855 e--;
1856 if ((es->style & ES_MULTILINE) && e &&
1857 (es->text[e - 1] == '\r') && (es->text[e] == '\n')) {
1858 e--;
1859 if (e && (es->text[e - 1] == '\r'))
1860 e--;
1861 }
1862 }
1863 EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, FALSE);
1864 EDIT_EM_ScrollCaret(es);

Referenced by EDIT_WM_Char(), EDIT_WM_KeyDown(), and EDIT_WM_Timer().

◆ EDIT_MoveDown_ML()

static void EDIT_MoveDown_ML ( EDITSTATE *  es,
BOOL  extend 
)
static

Definition at line 1876 of file edit.c.

1878{
1879 INT s = es->selection_start;
1880 INT e = es->selection_end;
1881 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1882 LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
1883 INT x = (short)LOWORD(pos);
1884 INT y = (short)HIWORD(pos);
1885
1886 e = EDIT_CharFromPos(es, x, y + es->line_height, &after_wrap);
1887 if (!extend)
1888 s = e;
1889 EDIT_EM_SetSel(es, s, e, after_wrap);
1890 EDIT_EM_ScrollCaret(es);
HIWORD
#define HIWORD(l)
Definition: typedefs.h:247

Referenced by EDIT_WM_Char(), and EDIT_WM_KeyDown().

◆ EDIT_MoveEnd()

static void EDIT_MoveEnd ( EDITSTATE *  es,
BOOL  extend,
BOOL  ctrl 
)
static

Definition at line 1898 of file edit.c.

1900{
1901 BOOL after_wrap = FALSE;
1902 INT e;
1903
1904 /* Pass a high value in x to make sure of receiving the end of the line */
1905 if (!ctrl && (es->style & ES_MULTILINE))
1906 e = EDIT_CharFromPos(es, 0x3fffffff,
1907 HIWORD(EDIT_EM_PosFromChar(es, es->selection_end, es->flags & EF_AFTER_WRAP)), &after_wrap);
1908 else
1909 e = get_text_length(es);
1910 EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, after_wrap);
1911 EDIT_EM_ScrollCaret(es);
ctrl
#define ctrl
Definition: input.c:1756

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveForward()

static void EDIT_MoveForward ( EDITSTATE *  es,
BOOL  extend 
)
static

Definition at line 1919 of file edit.c.

1921{
1922 INT e = es->selection_end;
1923
1924 if (es->text[e]) {
1925 e++;
1926 if ((es->style & ES_MULTILINE) && (es->text[e - 1] == '\r')) {
1927 if (es->text[e] == '\n')
1928 e++;
1929 else if ((es->text[e] == '\r') && (es->text[e + 1] == '\n'))
1930 e += 2;
1931 }
1932 }
1933 EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, FALSE);
1934 EDIT_EM_ScrollCaret(es);

Referenced by EDIT_WM_KeyDown(), and EDIT_WM_Timer().

◆ EDIT_MoveHome()

static void EDIT_MoveHome ( EDITSTATE *  es,
BOOL  extend,
BOOL  ctrl 
)
static

Definition at line 1944 of file edit.c.

1946{
1947 INT e;
1948
1949 /* Pass the x_offset in x to make sure of receiving the first position of the line */
1950 if (!ctrl && (es->style & ES_MULTILINE))
1951 e = EDIT_CharFromPos(es, -es->x_offset,
1952 HIWORD(EDIT_EM_PosFromChar(es, es->selection_end, es->flags & EF_AFTER_WRAP)), NULL);
1953 else
1954 e = 0;
1955 EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, FALSE);
1956 EDIT_EM_ScrollCaret(es);

Referenced by EDIT_WM_Char(), and EDIT_WM_KeyDown().

◆ EDIT_MovePageDown_ML()

static void EDIT_MovePageDown_ML ( EDITSTATE *  es,
BOOL  extend 
)
static

Definition at line 1968 of file edit.c.

1970{
1971 INT s = es->selection_start;
1972 INT e = es->selection_end;
1973 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
1974 LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
1975 INT x = (short)LOWORD(pos);
1976 INT y = (short)HIWORD(pos);
1977
1978 e = EDIT_CharFromPos(es, x,
1979 y + (es->format_rect.bottom - es->format_rect.top),
1980 &after_wrap);
1981 if (!extend)
1982 s = e;
1983 EDIT_EM_SetSel(es, s, e, after_wrap);
1984 EDIT_EM_ScrollCaret(es);

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MovePageUp_ML()

static void EDIT_MovePageUp_ML ( EDITSTATE *  es,
BOOL  extend 
)
static

Definition at line 1996 of file edit.c.

1998{
1999 INT s = es->selection_start;
2000 INT e = es->selection_end;
2001 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
2002 LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
2003 INT x = (short)LOWORD(pos);
2004 INT y = (short)HIWORD(pos);
2005
2006 e = EDIT_CharFromPos(es, x,
2007 y - (es->format_rect.bottom - es->format_rect.top),
2008 &after_wrap);
2009 if (!extend)
2010 s = e;
2011 EDIT_EM_SetSel(es, s, e, after_wrap);
2012 EDIT_EM_ScrollCaret(es);

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveUp_ML()

static void EDIT_MoveUp_ML ( EDITSTATE *  es,
BOOL  extend 
)
static

Definition at line 2024 of file edit.c.

2026{
2027 INT s = es->selection_start;
2028 INT e = es->selection_end;
2029 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
2030 LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
2031 INT x = (short)LOWORD(pos);
2032 INT y = (short)HIWORD(pos);
2033
2034 e = EDIT_CharFromPos(es, x, y - es->line_height, &after_wrap);
2035 if (!extend)
2036 s = e;
2037 EDIT_EM_SetSel(es, s, e, after_wrap);
2038 EDIT_EM_ScrollCaret(es);

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveWordBackward()

static void EDIT_MoveWordBackward ( EDITSTATE *  es,
BOOL  extend 
)
static

Definition at line 2046 of file edit.c.

2048{
2049 INT s = es->selection_start;
2050 INT e = es->selection_end;
2051 INT l;
2052 INT ll;
2053 INT li;
2054
2055 l = EDIT_EM_LineFromChar(es, e);
2056 ll = EDIT_EM_LineLength(es, e);
2057 li = EDIT_EM_LineIndex(es, l);
2058 if (e - li == 0) {
2059 if (l) {
2060 li = EDIT_EM_LineIndex(es, l - 1);
2061 e = li + EDIT_EM_LineLength(es, li);
2062 }
2063 } else {
2064 e = li + EDIT_CallWordBreakProc(es, li, e - li, ll, WB_LEFT);
2065 }
2066 if (!extend)
2067 s = e;
2068 EDIT_EM_SetSel(es, s, e, FALSE);
2069 EDIT_EM_ScrollCaret(es);
ll
w ll
Definition: byte_order.h:167

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveWordForward()

static void EDIT_MoveWordForward ( EDITSTATE *  es,
BOOL  extend 
)
static

Definition at line 2077 of file edit.c.

2079{
2080 INT s = es->selection_start;
2081 INT e = es->selection_end;
2082 INT l;
2083 INT ll;
2084 INT li;
2085
2086 l = EDIT_EM_LineFromChar(es, e);
2087 ll = EDIT_EM_LineLength(es, e);
2088 li = EDIT_EM_LineIndex(es, l);
2089 if (e - li == ll) {
2090 if ((es->style & ES_MULTILINE) && (l != es->line_count - 1))
2091 e = EDIT_EM_LineIndex(es, l + 1);
2092 } else {
2093 e = li + EDIT_CallWordBreakProc(es,
2094 li, e - li + 1, ll, WB_RIGHT);
2095 }
2096 if (!extend)
2097 s = e;
2098 EDIT_EM_SetSel(es, s, e, FALSE);
2099 EDIT_EM_ScrollCaret(es);
WB_RIGHT
#define WB_RIGHT
Definition: winuser.h:551

Referenced by EDIT_WM_KeyDown().

◆ EDIT_NotifyCtlColor()

static HBRUSH EDIT_NotifyCtlColor ( EDITSTATE *  es,
HDC  hdc 
)
static

Definition at line 198 of file edit.c.

200{
201 HBRUSH hbrush;
202 UINT msg;
203
204 if ((!es->bEnableState || (es->style & ES_READONLY)))
205 msg = WM_CTLCOLORSTATIC;
206 else
207 msg = WM_CTLCOLOREDIT;
208
209 /* Why do we notify to es->hwndParent, and we send this one to GetParent()? */
210 hbrush = (HBRUSH)SendMessageW(GetParent(es->hwndSelf), msg, (WPARAM)hdc, (LPARAM)es->hwndSelf);
211 if (!hbrush)
212 hbrush = (HBRUSH)DefWindowProcW(GetParent(es->hwndSelf), msg, (WPARAM)hdc, (LPARAM)es->hwndSelf);
213 return hbrush;
hbrush
static HBRUSH hbrush
Definition: NtGdiRestoreDC.c:10
hdc
HDC hdc
Definition: main.c:9
LPARAM
LONG_PTR LPARAM
Definition: windef.h:208
WPARAM
UINT_PTR WPARAM
Definition: windef.h:207
WM_CTLCOLORSTATIC
#define WM_CTLCOLORSTATIC
Definition: winuser.h:1775
DefWindowProcW
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
WM_CTLCOLOREDIT
#define WM_CTLCOLOREDIT
Definition: winuser.h:1770

Referenced by EDIT_WM_Paint().

◆ EDIT_PaintLine()

static void EDIT_PaintLine ( EDITSTATE *  es,
HDC  dc,
INT  line,
BOOL  rev 
)
static

Definition at line 2181 of file edit.c.

2183{
2184 INT s = 0;
2185 INT e = 0;
2186 INT li = 0;
2187 INT ll = 0;
2188 INT x;
2189 INT y;
2190 LRESULT pos;
2191 SCRIPT_STRING_ANALYSIS ssa;
2192
2193 if (es->style & ES_MULTILINE) {
2194 INT vlc = get_vertical_line_count(es);
2195
2196 if ((line < es->y_offset) || (line > es->y_offset + vlc) || (line >= es->line_count))
2197 return;
2198 } else if (line)
2199 return;
2200
2201 TRACE("line=%d\n", line);
2202
2203 ssa = EDIT_UpdateUniscribeData(es, dc, line);
2204 pos = EDIT_EM_PosFromChar(es, EDIT_EM_LineIndex(es, line), FALSE);
2205 x = (short)LOWORD(pos);
2206 y = (short)HIWORD(pos);
2207
2208 if (es->style & ES_MULTILINE)
2209 {
2210 int line_idx = line;
2211 x = -es->x_offset;
2212 if (es->style & ES_RIGHT || es->style & ES_CENTER)
2213 {
2214 LINEDEF *line_def = es->first_line_def;
2215 int w, lw;
2216
2217 while (line_def && line_idx)
2218 {
2219 line_def = line_def->next;
2220 line_idx--;
2221 }
2222 w = es->format_rect.right - es->format_rect.left;
2223 lw = line_def->width;
2224
2225 if (es->style & ES_RIGHT)
2226 x = w - (lw - x);
2227 else if (es->style & ES_CENTER)
2228 x += (w - lw) / 2;
2229 }
2230 x += es->format_rect.left;
2231 }
2232
2233 if (rev)
2234 {
2235 li = EDIT_EM_LineIndex(es, line);
2236 ll = EDIT_EM_LineLength(es, li);
2237 s = min(es->selection_start, es->selection_end);
2238 e = max(es->selection_start, es->selection_end);
2239 s = min(li + ll, max(li, s));
2240 e = min(li + ll, max(li, e));
2241 }
2242
2243 if (ssa)
2244 ScriptStringOut(ssa, x, y, 0, &es->format_rect, s - li, e - li, FALSE);
2245 else if (rev && (s != e) &&
2246 ((es->flags & EF_FOCUSED) || (es->style & ES_NOHIDESEL))) {
2247 x += EDIT_PaintText(es, dc, x, y, line, 0, s - li, FALSE);
2248 x += EDIT_PaintText(es, dc, x, y, line, s - li, e - s, TRUE);
2249 x += EDIT_PaintText(es, dc, x, y, line, e - li, li + ll - e, FALSE);
2250 } else
2251 x += EDIT_PaintText(es, dc, x, y, line, 0, ll, FALSE);
2252
2253 if (es->cue_banner_text && es->text_length == 0 && (!(es->flags & EF_FOCUSED) || es->cue_banner_draw_focused))
2254 {
2255 SetTextColor(dc, GetSysColor(COLOR_GRAYTEXT));
2256 TextOutW(dc, x, y, es->cue_banner_text, lstrlenW(es->cue_banner_text));
2257 }
rev
int rev
Definition: sort.c:17
EDIT_PaintText
static INT EDIT_PaintText(EDITSTATE *es, HDC dc, INT x, INT y, INT line, INT col, INT count, BOOL rev)
Definition: edit.c:2107
EF_FOCUSED
#define EF_FOCUSED
Definition: edit.c:66
ScriptStringOut
HRESULT WINAPI ScriptStringOut(SCRIPT_STRING_ANALYSIS ssa, int iX, int iY, UINT uOptions, const RECT *prc, int iMinSel, int iMaxSel, BOOL fDisabled)
Definition: usp10.c:2366
ES_NOHIDESEL
#define ES_NOHIDESEL
Definition: pedump.c:673
TextOutW
BOOL WINAPI TextOutW(_In_ HDC hdc, _In_ int x, _In_ int y, _In_reads_(c) LPCWSTR lpString, _In_ int c)
SetTextColor
COLORREF WINAPI SetTextColor(_In_ HDC, _In_ COLORREF)
Definition: text.c:918
GetSysColor
DWORD WINAPI GetSysColor(_In_ int)
COLOR_GRAYTEXT
#define COLOR_GRAYTEXT
Definition: winuser.h:935

Referenced by EDIT_WM_Paint().

◆ EDIT_PaintText()

static INT EDIT_PaintText ( EDITSTATE *  es,
HDC  dc,
INT  x,
INT  y,
INT  line,
INT  col,
INT  count,
BOOL  rev 
)
static

Definition at line 2107 of file edit.c.

2109{
2110 COLORREF BkColor;
2111 COLORREF TextColor;
2112 LOGFONTW underline_font;
2113 HFONT hUnderline = 0;
2114 HFONT old_font = 0;
2115 INT ret;
2116 INT li;
2117 INT BkMode;
2118 SIZE size;
2119
2120 if (!count)
2121 return 0;
2122 BkMode = GetBkMode(dc);
2123 BkColor = GetBkColor(dc);
2124 TextColor = GetTextColor(dc);
2125 if (rev) {
2126#ifdef __REACTOS__
2127 if (TRUE)
2128#else
2129 if (es->composition_len == 0)
2130#endif
2131 {
2132 SetBkColor(dc, GetSysColor(COLOR_HIGHLIGHT));
2133 SetTextColor(dc, GetSysColor(COLOR_HIGHLIGHTTEXT));
2134 SetBkMode( dc, OPAQUE);
2135 }
2136 else
2137 {
2138 HFONT current = GetCurrentObject(dc,OBJ_FONT);
2139 GetObjectW(current,sizeof(LOGFONTW),&underline_font);
2140 underline_font.lfUnderline = TRUE;
2141 hUnderline = CreateFontIndirectW(&underline_font);
2142 old_font = SelectObject(dc,hUnderline);
2143 }
2144 }
2145 li = EDIT_EM_LineIndex(es, line);
2146 if (es->style & ES_MULTILINE) {
2147 ret = (INT)LOWORD(TabbedTextOutW(dc, x, y, es->text + li + col, count,
2148 es->tabs_count, es->tabs, es->format_rect.left - es->x_offset));
2149 } else {
2150 TextOutW(dc, x, y, es->text + li + col, count);
2151 GetTextExtentPoint32W(dc, es->text + li + col, count, &size);
2152 ret = size.cx;
2153 }
2154 if (rev) {
2155#ifdef __REACTOS__
2156 if (TRUE)
2157#else
2158 if (es->composition_len == 0)
2159#endif
2160 {
2161 SetBkColor(dc, BkColor);
2162 SetTextColor(dc, TextColor);
2163 SetBkMode( dc, BkMode);
2164 }
2165 else
2166 {
2167 if (old_font)
2168 SelectObject(dc,old_font);
2169 if (hUnderline)
2170 DeleteObject(hUnderline);
2171 }
2172 }
2173 return ret;
current
struct task_struct * current
Definition: linux.c:32
OBJ_FONT
#define OBJ_FONT
Definition: objidl.idl:1414
INT
#define INT
Definition: polytest.cpp:20
LOGFONTW::lfUnderline
BYTE lfUnderline
Definition: dimm.idl:65
COLORREF
DWORD COLORREF
Definition: windef.h:300
GetBkMode
int WINAPI GetBkMode(_In_ HDC)
GetObjectW
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
SetBkColor
COLORREF WINAPI SetBkColor(_In_ HDC, _In_ COLORREF)
Definition: dc.c:999
GetTextColor
COLORREF WINAPI GetTextColor(_In_ HDC)
Definition: text.c:861
GetCurrentObject
HGDIOBJ WINAPI GetCurrentObject(_In_ HDC, _In_ UINT)
Definition: dc.c:428
GetBkColor
COLORREF WINAPI GetBkColor(_In_ HDC)
Definition: dc.c:978
OPAQUE
#define OPAQUE
Definition: wingdi.h:949
CreateFontIndirectW
HFONT WINAPI CreateFontIndirectW(_In_ const LOGFONTW *)
SetBkMode
int WINAPI SetBkMode(_In_ HDC, _In_ int)
Definition: dc.c:1056
GetTextExtentPoint32W
BOOL WINAPI GetTextExtentPoint32W(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpString, _In_ int c, _Out_ LPSIZE psizl)
COLOR_HIGHLIGHT
#define COLOR_HIGHLIGHT
Definition: winuser.h:929
COLOR_HIGHLIGHTTEXT
#define COLOR_HIGHLIGHTTEXT
Definition: winuser.h:930
TabbedTextOutW
LONG WINAPI TabbedTextOutW(_In_ HDC hdc, _In_ int x, _In_ int y, _In_reads_(chCount) LPCWSTR lpString, _In_ int chCount, _In_ int nTabPositions, _In_reads_opt_(nTabPositions) CONST INT *lpnTabStopPositions, _In_ int nTabOrigin)

Referenced by EDIT_PaintLine().

◆ EDIT_Register()

void EDIT_Register ( void  )

Definition at line 5279 of file edit.c.

5281{
5282 WNDCLASSW wndClass;
5283
5284 memset(&wndClass, 0, sizeof(wndClass));
5285 wndClass.style = CS_PARENTDC | CS_GLOBALCLASS | CS_DBLCLKS;
5286 wndClass.lpfnWndProc = EDIT_WindowProc;
5287 wndClass.cbClsExtra = 0;
5288#ifdef __i386__
5289 wndClass.cbWndExtra = sizeof(EDITSTATE *) + sizeof(WORD);
5290#else
5291 wndClass.cbWndExtra = sizeof(EDITSTATE *);
5292#endif
5293 wndClass.hCursor = LoadCursorW(0, (LPWSTR)IDC_IBEAM);
5294 wndClass.hbrBackground = NULL;
5295 wndClass.lpszClassName = WC_EDITW;
5296 RegisterClassW(&wndClass);
EDIT_WindowProc
static LRESULT CALLBACK EDIT_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
Definition: edit.c:4717
WC_EDITW
#define WC_EDITW
Definition: commctrl.h:4692
memset
#define memset(x, y, z)
Definition: compat.h:39
EDITSTATE
Definition: edit.c:96
_WNDCLASSW
Definition: winuser.h:3178
_WNDCLASSW::lpszClassName
LPCWSTR lpszClassName
Definition: winuser.h:3188
_WNDCLASSW::hbrBackground
HBRUSH hbrBackground
Definition: winuser.h:3186
_WNDCLASSW::cbClsExtra
int cbClsExtra
Definition: winuser.h:3181
_WNDCLASSW::style
UINT style
Definition: winuser.h:3179
_WNDCLASSW::lpfnWndProc
WNDPROC lpfnWndProc
Definition: winuser.h:3180
_WNDCLASSW::cbWndExtra
int cbWndExtra
Definition: winuser.h:3182
_WNDCLASSW::hCursor
HCURSOR hCursor
Definition: winuser.h:3185
RegisterClassW
ATOM WINAPI RegisterClassW(_In_ CONST WNDCLASSW *)
CS_DBLCLKS
#define CS_DBLCLKS
Definition: winuser.h:651
LoadCursorW
HCURSOR WINAPI LoadCursorW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
Definition: cursoricon.c:2157
IDC_IBEAM
#define IDC_IBEAM
Definition: winuser.h:688
CS_GLOBALCLASS
#define CS_GLOBALCLASS
Definition: winuser.h:652
CS_PARENTDC
#define CS_PARENTDC
Definition: winuser.h:656

Referenced by DllMain().

◆ EDIT_SetCaretPos()

static void EDIT_SetCaretPos ( EDITSTATE *  es,
INT  pos,
BOOL  after_wrap 
)
static

Definition at line 1750 of file edit.c.

1753{
1754 LRESULT res = EDIT_EM_PosFromChar(es, pos, after_wrap);
1755#ifdef __REACTOS__
1756 HKL hKL = GetKeyboardLayout(0);
1757 POINT pt = { (short)LOWORD(res), (short)HIWORD(res) };
1758
1759 /* Don't set caret if not focused */
1760 if ((es->flags & EF_FOCUSED) == 0)
1761 return;
1762
1763 SetCaretPos(pt.x, pt.y);
1764
1765 if (!ImmIsIME(hKL))
1766 return;
1767
1768 EDIT_ImmSetCompositionWindow(es, pt);
1769#else
1770 TRACE("%d - %dx%d\n", pos, (short)LOWORD(res), (short)HIWORD(res));
1771 SetCaretPos((short)LOWORD(res), (short)HIWORD(res));
1772#endif
ImmIsIME
BOOL WINAPI ImmIsIME(HKL hKL)
Definition: ime.c:880
res
GLuint res
Definition: glext.h:9613
HKL
UINT_PTR HKL
Definition: msctf.idl:143
GetKeyboardLayout
HKL WINAPI GetKeyboardLayout(_In_ DWORD)
SetCaretPos
BOOL WINAPI SetCaretPos(_In_ int, _In_ int)

Referenced by EDIT_AdjustFormatRect(), EDIT_EM_ScrollCaret(), EDIT_ImeComposition(), EDIT_WM_MouseMove(), EDIT_WM_SetFocus(), and EDIT_WM_SetFont().

◆ EDIT_SetRectNP()

static void EDIT_SetRectNP ( EDITSTATE *  es,
const RECT *  rc 
)
static

Definition at line 2319 of file edit.c.

2321{
2322 LONG_PTR ExStyle;
2323 INT bw, bh;
2324 ExStyle = GetWindowLongPtrW(es->hwndSelf, GWL_EXSTYLE);
2325
2326 CopyRect(&es->format_rect, rc);
2327
2328 if (ExStyle & WS_EX_CLIENTEDGE) {
2329 es->format_rect.left++;
2330 es->format_rect.right--;
2331
2332 if (es->format_rect.bottom - es->format_rect.top
2333 >= es->line_height + 2)
2334 {
2335 es->format_rect.top++;
2336 es->format_rect.bottom--;
2337 }
2338 }
2339 else if (es->style & WS_BORDER) {
2340 bw = GetSystemMetrics(SM_CXBORDER) + 1;
2341 bh = GetSystemMetrics(SM_CYBORDER) + 1;
2342 InflateRect(&es->format_rect, -bw, 0);
2343 if (es->format_rect.bottom - es->format_rect.top >= es->line_height + 2 * bh)
2344 InflateRect(&es->format_rect, 0, -bh);
2345 }
2346
2347 es->format_rect.left += es->left_margin;
2348 es->format_rect.right -= es->right_margin;
2349 EDIT_AdjustFormatRect(es);
bw
static int bw
Definition: maze.c:120
ExStyle
const DWORD ExStyle
Definition: appswitch.c:72
LONG_PTR
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
WS_BORDER
#define WS_BORDER
Definition: pedump.c:625
CopyRect
BOOL WINAPI CopyRect(_Out_ LPRECT, _In_ LPCRECT)
GetWindowLongPtrW
#define GetWindowLongPtrW
Definition: winuser.h:4832
SM_CYBORDER
#define SM_CYBORDER
Definition: winuser.h:968
SM_CXBORDER
#define SM_CXBORDER
Definition: winuser.h:967
WS_EX_CLIENTEDGE
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
InflateRect
BOOL WINAPI InflateRect(_Inout_ LPRECT, _In_ int, _In_ int)
GetSystemMetrics
int WINAPI GetSystemMetrics(_In_ int)
GWL_EXSTYLE
#define GWL_EXSTYLE
Definition: winuser.h:854

Referenced by EDIT_WindowProc(), EDIT_WM_Create(), EDIT_WM_SetFont(), EDIT_WM_Size(), and EditWndProc_common().

◆ EDIT_SL_InvalidateText()

static void EDIT_SL_InvalidateText ( EDITSTATE *  es,
INT  start,
INT  end 
)
static

Definition at line 1376 of file edit.c.

1378{
1379 RECT line_rect;
1380 RECT rc;
1381
1382 EDIT_GetLineRect(es, 0, start, end, &line_rect);
1383 if (IntersectRect(&rc, &line_rect, &es->format_rect))
1384 EDIT_UpdateText(es, &rc, TRUE);

Referenced by EDIT_InvalidateText().

◆ EDIT_UnlockBuffer()

static void EDIT_UnlockBuffer ( EDITSTATE *  es,
BOOL  force 
)
static

Definition at line 1230 of file edit.c.

1232{
1233 /* Edit window might be already destroyed */
1234 if (!IsWindow(es->hwndSelf))
1235 {
1236 WARN("edit hwnd %p already destroyed\n", es->hwndSelf);
1237 return;
1238 }
1239
1240 if (!es->lock_count)
1241 {
1242 ERR("lock_count == 0 ... please report\n");
1243 return;
1244 }
1245
1246 if (!es->text)
1247 {
1248 ERR("es->text == 0 ... please report\n");
1249 return;
1250 }
1251
1252 if (force || (es->lock_count == 1))
1253 {
1254 if (es->hloc32W)
1255 {
1256 LocalUnlock(es->hloc32W);
1257 es->text = NULL;
1258 }
1259 else
1260 {
1261 ERR("no buffer ... please report\n");
1262 return;
1263 }
1264
1265 }
1266
1267 es->lock_count--;
LocalUnlock
BOOL NTAPI LocalUnlock(HLOCAL hMem)
Definition: heapmem.c:1805
IsWindow
BOOL WINAPI IsWindow(_In_opt_ HWND)

Referenced by EDIT_EM_GetHandle(), EDIT_EM_SetHandle(), and EDIT_MakeFit().

◆ EDIT_UpdateScrollInfo()

static void EDIT_UpdateScrollInfo ( EDITSTATE *  es)
static

Definition at line 1560 of file edit.c.

1562{
1563 if ((es->style & WS_VSCROLL) && !(es->flags & EF_VSCROLL_TRACK))
1564 {
1565 SCROLLINFO si;
1566 si.cbSize = sizeof(SCROLLINFO);
1567 si.fMask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_DISABLENOSCROLL;
1568 si.nMin = 0;
1569 si.nMax = es->line_count - 1;
1570 si.nPage = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
1571 si.nPos = es->y_offset;
1572 TRACE("SB_VERT, nMin=%d, nMax=%d, nPage=%d, nPos=%d\n",
1573 si.nMin, si.nMax, si.nPage, si.nPos);
1574 SetScrollInfo(es->hwndSelf, SB_VERT, &si, TRUE);
1575 }
1576
1577 if ((es->style & WS_HSCROLL) && !(es->flags & EF_HSCROLL_TRACK))
1578 {
1579 SCROLLINFO si;
1580 si.cbSize = sizeof(SCROLLINFO);
1581 si.fMask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_DISABLENOSCROLL;
1582 si.nMin = 0;
1583 si.nMax = es->text_width - 1;
1584 si.nPage = es->format_rect.right - es->format_rect.left;
1585 si.nPos = es->x_offset;
1586 TRACE("SB_HORZ, nMin=%d, nMax=%d, nPage=%d, nPos=%d\n",
1587 si.nMin, si.nMax, si.nPage, si.nPos);
1588 SetScrollInfo(es->hwndSelf, SB_HORZ, &si, TRUE);
1589 }
WS_VSCROLL
#define WS_VSCROLL
Definition: pedump.c:627
WS_HSCROLL
#define WS_HSCROLL
Definition: pedump.c:628
SCROLLINFO
struct tagSCROLLINFO SCROLLINFO
SIF_RANGE
#define SIF_RANGE
Definition: winuser.h:1238
SB_VERT
#define SB_VERT
Definition: winuser.h:553
SIF_PAGE
#define SIF_PAGE
Definition: winuser.h:1236
SIF_DISABLENOSCROLL
#define SIF_DISABLENOSCROLL
Definition: winuser.h:1239
SIF_POS
#define SIF_POS
Definition: winuser.h:1237
SetScrollInfo
int WINAPI SetScrollInfo(_In_ HWND, _In_ int, _In_ LPCSCROLLINFO, _In_ BOOL)
SB_HORZ
#define SB_HORZ
Definition: winuser.h:552

Referenced by EDIT_AdjustFormatRect(), EDIT_EM_LineScroll_internal(), EDIT_EM_ReplaceSel(), EDIT_EM_SetHandle(), EDIT_WM_Create(), EDIT_WM_HScroll(), EDIT_WM_SetText(), and EDIT_WM_VScroll().

◆ EDIT_UpdateText()

static void EDIT_UpdateText ( EDITSTATE *  es,
const RECT *  rc,
BOOL  bErase 
)
static

Definition at line 1359 of file edit.c.

1361{
1362 if (es->flags & EF_UPDATE) {
1363 es->flags &= ~EF_UPDATE;
1364 if (!notify_parent(es, EN_UPDATE)) return;
1365 }
1366 InvalidateRect(es->hwndSelf, rc, bErase);
EN_UPDATE
#define EN_UPDATE
Definition: winuser.h:2031
InvalidateRect
BOOL WINAPI InvalidateRect(_In_opt_ HWND, _In_opt_ LPCRECT, _In_ BOOL)

Referenced by EDIT_EM_ReplaceSel(), EDIT_EM_ScrollCaret(), EDIT_EM_SetHandle(), EDIT_EM_SetMargins(), EDIT_EM_SetPasswordChar(), EDIT_EM_SetWordBreakProc(), EDIT_ML_InvalidateText(), EDIT_SL_InvalidateText(), EDIT_WindowProc(), EDIT_WM_SetFont(), EDIT_WM_Size(), and EditWndProc_common().

◆ EDIT_UpdateTextRegion()

static void EDIT_UpdateTextRegion ( EDITSTATE *  es,
HRGN  hrgn,
BOOL  bErase 
)
static

Definition at line 1344 of file edit.c.

1346{
1347 if (es->flags & EF_UPDATE) {
1348 es->flags &= ~EF_UPDATE;
1349 if (!notify_parent(es, EN_UPDATE)) return;
1350 }
1351 InvalidateRgn(es->hwndSelf, hrgn, bErase);
InvalidateRgn
BOOL WINAPI InvalidateRgn(_In_ HWND, _In_opt_ HRGN, _In_ BOOL)

Referenced by EDIT_EM_ReplaceSel().

◆ EDIT_UpdateUniscribeData()

static SCRIPT_STRING_ANALYSIS EDIT_UpdateUniscribeData ( EDITSTATE *  es,
HDC  dc,
INT  line 
)
static

Definition at line 372 of file edit.c.

374{
375 LINEDEF *line_def;
376
377 if (!(es->style & ES_MULTILINE))
378 {
379 if (!es->ssa)
380 {
381 INT length = get_text_length(es);
382 HFONT old_font = NULL;
383 HDC udc = dc;
384
385 if (!udc)
386 udc = GetDC(es->hwndSelf);
387 if (es->font)
388 old_font = SelectObject(udc, es->font);
389
390 if (es->style & ES_PASSWORD)
391 ScriptStringAnalyse(udc, &es->password_char, length, (1.5*length+16), -1, SSA_LINK|SSA_FALLBACK|SSA_GLYPHS|SSA_PASSWORD, -1, NULL, NULL, NULL, NULL, NULL, &es->ssa);
392 else
393 ScriptStringAnalyse(udc, es->text, length, (1.5*length+16), -1, SSA_LINK|SSA_FALLBACK|SSA_GLYPHS, -1, NULL, NULL, NULL, NULL, NULL, &es->ssa);
394
395 if (es->font)
396 SelectObject(udc, old_font);
397 if (udc != dc)
398 ReleaseDC(es->hwndSelf, udc);
399 }
400 return es->ssa;
401 }
402 else
403 {
404 line_def = es->first_line_def;
405 while (line_def && line)
406 {
407 line_def = line_def->next;
408 line--;
409 }
410
411 return EDIT_UpdateUniscribeData_linedef(es,dc,line_def);
412 }
ScriptStringAnalyse
HRESULT WINAPI ScriptStringAnalyse(HDC hdc, const void *pString, int cString, int cGlyphs, int iCharset, DWORD dwFlags, int iReqWidth, SCRIPT_CONTROL *psControl, SCRIPT_STATE *psState, const int *piDx, SCRIPT_TABDEF *pTabdef, const BYTE *pbInClass, SCRIPT_STRING_ANALYSIS *pssa)
Definition: usp10.c:1985
length
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
SSA_FALLBACK
#define SSA_FALLBACK
Definition: usp10.h:38
SSA_LINK
#define SSA_LINK
Definition: usp10.h:45
SSA_PASSWORD
#define SSA_PASSWORD
Definition: usp10.h:33
SSA_GLYPHS
#define SSA_GLYPHS
Definition: usp10.h:40

Referenced by EDIT_CalcLineWidth_SL(), EDIT_CharFromPos(), EDIT_EM_PosFromChar(), EDIT_PaintLine(), and EDIT_WM_Paint().

◆ EDIT_UpdateUniscribeData_linedef()

static SCRIPT_STRING_ANALYSIS EDIT_UpdateUniscribeData_linedef ( EDITSTATE *  es,
HDC  dc,
LINEDEF *  line_def 
)
static

Definition at line 330 of file edit.c.

332{
333 if (!line_def)
334 return NULL;
335
336 if (line_def->net_length && !line_def->ssa)
337 {
338 int index = line_def->index;
339 HFONT old_font = NULL;
340 HDC udc = dc;
341 SCRIPT_TABDEF tabdef;
342 HRESULT hr;
343
344 if (!udc)
345 udc = GetDC(es->hwndSelf);
346 if (es->font)
347 old_font = SelectObject(udc, es->font);
348
349 tabdef.cTabStops = es->tabs_count;
350 tabdef.iScale = GdiGetCharDimensions(udc, NULL, NULL);
351 tabdef.pTabStops = es->tabs;
352 tabdef.iTabOrigin = 0;
353
354 hr = ScriptStringAnalyse(udc, &es->text[index], line_def->net_length,
355 (1.5*line_def->net_length+16), -1,
356 SSA_LINK|SSA_FALLBACK|SSA_GLYPHS|SSA_TAB, -1,
357 NULL, NULL, NULL, &tabdef, NULL, &line_def->ssa);
358 if (FAILED(hr))
359 {
360 WARN("ScriptStringAnalyse failed (%x)\n",hr);
361 line_def->ssa = NULL;
362 }
363
364 if (es->font)
365 SelectObject(udc, old_font);
366 if (udc != dc)
367 ReleaseDC(es->hwndSelf, udc);
368 }
369
370 return line_def->ssa;
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
hr
HRESULT hr
Definition: shlfolder.c:183
tag_SCRIPT_TABDEF
Definition: usp10.h:170
tag_SCRIPT_TABDEF::pTabStops
int * pTabStops
Definition: usp10.h:173
tag_SCRIPT_TABDEF::iTabOrigin
int iTabOrigin
Definition: usp10.h:174
tag_SCRIPT_TABDEF::iScale
int iScale
Definition: usp10.h:172
tag_SCRIPT_TABDEF::cTabStops
int cTabStops
Definition: usp10.h:171
SSA_TAB
#define SSA_TAB
Definition: usp10.h:34

Referenced by EDIT_BuildLineDefs_ML(), and EDIT_UpdateUniscribeData().

◆ EDIT_WindowProc()

static LRESULT CALLBACK EDIT_WindowProc ( HWND  hwnd,
UINT  msg,
WPARAM  wParam,
LPARAM  lParam 
)
static

Definition at line 4717 of file edit.c.

4719{
4720 EDITSTATE *es = (EDITSTATE *)GetWindowLongPtrW(hwnd, 0);
4721 HTHEME theme = GetWindowTheme(hwnd);
4722 LRESULT result = 0;
4723 RECT *rect;
4724
4725 TRACE("hwnd=%p msg=%#x wparam=%lx lparam=%lx\n", hwnd, msg, wParam, lParam);
4726
4727 if (!es && msg != WM_NCCREATE)
4728 return DefWindowProcW(hwnd, msg, wParam, lParam);
4729
4730 if (es && (msg != WM_NCDESTROY))
4731 EDIT_LockBuffer(es);
4732
4733 switch (msg)
4734 {
4735 case EM_GETSEL:
4736 result = EDIT_EM_GetSel(es, (UINT *)wParam, (UINT *)lParam);
4737 break;
4738
4739 case EM_SETSEL:
4740 EDIT_EM_SetSel(es, wParam, lParam, FALSE);
4741 EDIT_EM_ScrollCaret(es);
4742 result = 1;
4743 break;
4744
4745 case EM_GETRECT:
4746 rect = (RECT *)lParam;
4747 if (rect)
4748 *rect = es->format_rect;
4749 break;
4750
4751 case EM_SETRECT:
4752 if ((es->style & ES_MULTILINE) && lParam)
4753 {
4754 EDIT_SetRectNP(es, (RECT *)lParam);
4755 EDIT_UpdateText(es, NULL, TRUE);
4756 }
4757 break;
4758
4759 case EM_SETRECTNP:
4760 if ((es->style & ES_MULTILINE) && lParam)
4761 EDIT_SetRectNP(es, (LPRECT)lParam);
4762 break;
4763
4764 case EM_SCROLL:
4765 result = EDIT_EM_Scroll(es, (INT)wParam);
4766 break;
4767
4768 case EM_LINESCROLL:
4769 result = (LRESULT)EDIT_EM_LineScroll(es, (INT)wParam, (INT)lParam);
4770 break;
4771
4772 case EM_SCROLLCARET:
4773 EDIT_EM_ScrollCaret(es);
4774 result = 1;
4775 break;
4776
4777 case EM_GETMODIFY:
4778 result = ((es->flags & EF_MODIFIED) != 0);
4779 break;
4780
4781 case EM_SETMODIFY:
4782 if (wParam)
4783 es->flags |= EF_MODIFIED;
4784 else
4785 es->flags &= ~(EF_MODIFIED | EF_UPDATE); /* reset pending updates */
4786 break;
4787
4788 case EM_GETLINECOUNT:
4789 result = (es->style & ES_MULTILINE) ? es->line_count : 1;
4790 break;
4791
4792 case EM_LINEINDEX:
4793 result = (LRESULT)EDIT_EM_LineIndex(es, (INT)wParam);
4794 break;
4795
4796 case EM_SETHANDLE:
4797 EDIT_EM_SetHandle(es, (HLOCAL)wParam);
4798 break;
4799
4800 case EM_GETHANDLE:
4801 result = (LRESULT)EDIT_EM_GetHandle(es);
4802 break;
4803
4804 case EM_GETTHUMB:
4805 result = EDIT_EM_GetThumb(es);
4806 break;
4807
4808 /* these messages missing from specs */
4809 case 0x00bf:
4810 case 0x00c0:
4811 case 0x00c3:
4812 case 0x00ca:
4813 FIXME("undocumented message 0x%x, please report\n", msg);
4814 result = DefWindowProcW(hwnd, msg, wParam, lParam);
4815 break;
4816
4817 case EM_LINELENGTH:
4818 result = (LRESULT)EDIT_EM_LineLength(es, (INT)wParam);
4819 break;
4820
4821 case EM_REPLACESEL:
4822 {
4823 const WCHAR *textW = (const WCHAR *)lParam;
4824
4825 EDIT_EM_ReplaceSel(es, (BOOL)wParam, textW, lstrlenW(textW), TRUE, TRUE);
4826 result = 1;
4827 break;
4828 }
4829
4830 case EM_GETLINE:
4831 result = (LRESULT)EDIT_EM_GetLine(es, (INT)wParam, (LPWSTR)lParam);
4832 break;
4833
4834 case EM_SETLIMITTEXT:
4835 EDIT_EM_SetLimitText(es, wParam);
4836 break;
4837
4838 case EM_CANUNDO:
4839 result = (LRESULT)EDIT_EM_CanUndo(es);
4840 break;
4841
4842 case EM_UNDO:
4843 case WM_UNDO:
4844 result = (LRESULT)EDIT_EM_Undo(es);
4845 break;
4846
4847 case EM_FMTLINES:
4848 result = (LRESULT)EDIT_EM_FmtLines(es, (BOOL)wParam);
4849 break;
4850
4851 case EM_LINEFROMCHAR:
4852 result = (LRESULT)EDIT_EM_LineFromChar(es, (INT)wParam);
4853 break;
4854
4855 case EM_SETTABSTOPS:
4856 result = (LRESULT)EDIT_EM_SetTabStops(es, (INT)wParam, (LPINT)lParam);
4857 break;
4858
4859 case EM_SETPASSWORDCHAR:
4860 EDIT_EM_SetPasswordChar(es, wParam);
4861 break;
4862
4863 case EM_EMPTYUNDOBUFFER:
4864 EDIT_EM_EmptyUndoBuffer(es);
4865 break;
4866
4867 case EM_GETFIRSTVISIBLELINE:
4868 result = (es->style & ES_MULTILINE) ? es->y_offset : es->x_offset;
4869 break;
4870
4871 case EM_SETREADONLY:
4872 {
4873 DWORD old_style = es->style;
4874
4875 if (wParam)
4876 {
4877 SetWindowLongW(hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE) | ES_READONLY);
4878 es->style |= ES_READONLY;
4879 }
4880 else
4881 {
4882 SetWindowLongW(hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE) & ~ES_READONLY);
4883 es->style &= ~ES_READONLY;
4884 }
4885
4886 if (old_style ^ es->style)
4887 InvalidateRect(es->hwndSelf, NULL, TRUE);
4888
4889 result = 1;
4890 break