ReactOS 0.4.15-dev-8348-gc1b9bb5
edit.c File Reference
#include <user32.h>
#include <usp10.h>
Include dependency graph for edit.c:

Go to the source code of this file.

Classes

struct  tagLINEDEF
 
struct  EDITSTATE
 

Macros

#define WIN32_LEAN_AND_MEAN
 
#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 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)
 
 WINE_DECLARE_DEBUG_CHANNEL (combo)
 
 WINE_DECLARE_DEBUG_CHANNEL (relay)
 
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 DWORD get_app_version (void)
 
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 void 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, BOOL unicode)
 
static LRESULT EDIT_EM_GetSel (const EDITSTATE *es, PUINT start, PUINT end)
 
static void EDIT_EM_ReplaceSel (EDITSTATE *es, BOOL can_undo, LPCWSTR lpsz_replace, 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 (UINT charset)
 
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, void *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, BOOL unicode)
 
static BOOL EDIT_CheckCombo (EDITSTATE *es, UINT msg, INT key)
 
static LRESULT EDIT_WM_KeyDown (EDITSTATE *es, INT key)
 
static LRESULT EDIT_WM_KillFocus (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_SetFocus (EDITSTATE *es)
 
static void EDIT_WM_SetFont (EDITSTATE *es, HFONT font, BOOL redraw)
 
static void EDIT_WM_SetText (EDITSTATE *es, LPCWSTR text, BOOL unicode)
 
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 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, BOOL unicode)
 
static LRESULT EDIT_WM_Create (EDITSTATE *es, LPCWSTR name)
 
static LRESULT EDIT_WM_NCDestroy (EDITSTATE *es)
 
static LRESULT DefWindowProcT (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode)
 
LRESULT WINAPI EditWndProc_common (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode)
 

Variables

static const WCHAR empty_stringW [] = {0}
 
static const WCHAR editW [] = {'E','d','i','t',0}
 
const struct builtin_class_descr EDIT_builtin_class
 

Macro Definition Documentation

◆ BUFLIMIT_INITIAL

#define BUFLIMIT_INITIAL   30000 /* initial buffer size */

Definition at line 66 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 79 of file edit.c.

◆ EF_DIALOGMODE

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

Definition at line 81 of file edit.c.

◆ EF_FOCUSED

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

Definition at line 75 of file edit.c.

◆ EF_HSCROLL_TRACK

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

Definition at line 78 of file edit.c.

◆ EF_MODIFIED

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

Definition at line 74 of file edit.c.

◆ EF_UPDATE

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

Definition at line 76 of file edit.c.

◆ EF_USE_SOFTBRK

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

Definition at line 80 of file edit.c.

◆ EF_VSCROLL_TRACK

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

Definition at line 77 of file edit.c.

◆ GROWLENGTH

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

Definition at line 67 of file edit.c.

◆ HSCROLL_FRACTION

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

Definition at line 69 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 171 of file edit.c.

◆ ROUND_TO_GROW

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

Definition at line 68 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 170 of file edit.c.

◆ WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 46 of file edit.c.

Typedef Documentation

◆ LINEDEF

Enumeration Type Documentation

◆ 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 83 of file edit.c.

85{
86 END_0 = 0, /* line ends with terminating '\0' character */
87 END_WRAP, /* line is wrapped */
88 END_HARD, /* line ends with a hard return '\r\n' */
89 END_SOFT, /* line ends with a soft return '\r\r\n' */
90 END_RICH /* line ends with a single '\n' */
@ END_SOFT
Definition: edit.c:86
@ END_RICH
Definition: edit.c:87
@ END_HARD
Definition: edit.c:85
@ END_0
Definition: edit.c:83
@ END_WRAP
Definition: edit.c:84

Function Documentation

◆ DefWindowProcT()

static LRESULT DefWindowProcT ( HWND  hwnd,
UINT  msg,
WPARAM  wParam,
LPARAM  lParam,
BOOL  unicode 
)
inlinestatic

Definition at line 4839 of file edit.c.

4841{
4842 if(unicode)
4843 return DefWindowProcW(hwnd, msg, wParam, lParam);
4844 else
4845 return DefWindowProcA(hwnd, msg, wParam, lParam);
#define msg(x)
Definition: auth_time.c:54
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
LRESULT WINAPI DefWindowProcA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

Referenced by EditWndProc_common().

◆ EDIT_AdjustFormatRect()

static void EDIT_AdjustFormatRect ( EDITSTATE es)
static

Definition at line 2415 of file edit.c.

2417{
2418 RECT ClientRect;
2419
2420 es->format_rect.right = max(es->format_rect.right, es->format_rect.left + es->char_width);
2421 if (es->style & ES_MULTILINE)
2422 {
2423 INT fw, vlc, max_x_offset, max_y_offset;
2424
2426 es->format_rect.bottom = es->format_rect.top + vlc * es->line_height;
2427
2428 /* correct es->x_offset */
2429 fw = es->format_rect.right - es->format_rect.left;
2430 max_x_offset = es->text_width - fw;
2431 if(max_x_offset < 0) max_x_offset = 0;
2432 if(es->x_offset > max_x_offset)
2433 es->x_offset = max_x_offset;
2434
2435 /* correct es->y_offset */
2436 max_y_offset = es->line_count - vlc;
2437 if(max_y_offset < 0) max_y_offset = 0;
2438 if(es->y_offset > max_y_offset)
2439 es->y_offset = max_y_offset;
2440
2441 /* force scroll info update */
2443 }
2444 else
2445 /* Windows doesn't care to fix text placement for SL controls */
2446 es->format_rect.bottom = es->format_rect.top + es->line_height;
2447
2448 /* Always stay within the client area */
2449 GetClientRect(es->hwndSelf, &ClientRect);
2450 es->format_rect.bottom = min(es->format_rect.bottom, ClientRect.bottom);
2451
2452 if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL))
2454
2455 EDIT_SetCaretPos(es, es->selection_end, es->flags & EF_AFTER_WRAP);
#define NULL
Definition: types.h:112
static INT get_vertical_line_count(EDITSTATE *es)
Definition: edit.c:416
#define EF_AFTER_WRAP
Definition: edit.c:75
static void EDIT_SetCaretPos(EDITSTATE *es, INT pos, BOOL after_wrap)
Definition: edit.c:1748
static void EDIT_BuildLineDefs_ML(EDITSTATE *es, INT istart, INT iend, INT delta, HRGN hrgn)
Definition: edit.c:431
static UINT get_text_length(EDITSTATE *es)
Definition: edit.c:218
static void EDIT_UpdateScrollInfo(EDITSTATE *es)
Definition: edit.c:1558
#define es
Definition: i386-dis.c:440
#define min(a, b)
Definition: monoChain.cc:55
#define ES_AUTOHSCROLL
Definition: pedump.c:672
#define ES_MULTILINE
Definition: pedump.c:667
LONG bottom
Definition: windef.h:309
#define max(a, b)
Definition: svc.c:63
int32_t INT
Definition: typedefs.h:58
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)

◆ EDIT_BuildLineDefs_ML()

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

Definition at line 520 of file edit.c.

522{
523 LPWSTR current_position, cp;
524 INT fw;
525 LINEDEF *current_line;
526 LINEDEF *previous_line;
527 LINEDEF *start_line;
528 INT line_index = 0, nstart_line, nstart_index;
529 INT line_count = es->line_count;
530 INT orig_net_length;
531 RECT rc;
532 INT vlc;
533
534 if (istart == iend && delta == 0)
535 return;
536
537 previous_line = NULL;
538 current_line = es->first_line_def;
539
540 /* Find starting line. istart must lie inside an existing line or
541 * at the end of buffer */
542 do {
543 if (istart < current_line->index + current_line->length ||
544 current_line->ending == END_0)
545 break;
546
547 previous_line = current_line;
548 current_line = current_line->next;
549 line_index++;
550 } while (current_line);
551
552 if (!current_line) /* Error occurred start is not inside previous buffer */
553 {
554 FIXME(" modification occurred outside buffer\n");
555 return;
556 }
557
558 /* Remember start of modifications in order to calculate update region */
559 nstart_line = line_index;
560 nstart_index = current_line->index;
561
562 /* We must start to reformat from the previous line since the modifications
563 * may have caused the line to wrap upwards. */
564 if (!(es->style & ES_AUTOHSCROLL) && line_index > 0)
565 {
566 line_index--;
567 current_line = previous_line;
568 }
569 start_line = current_line;
570
571 fw = es->format_rect.right - es->format_rect.left;
572 current_position = es->text + current_line->index;
574 do {
575 if (current_line != start_line)
576 {
577 if (!current_line || current_line->index + delta > current_position - es->text)
578 {
579 /* The buffer has been expanded, create a new line and
580 insert it into the link list */
582#ifdef __REACTOS__
583 /* ReactOS r33509 */
584 if (new_line == NULL)
585 break;
586#endif
587 new_line->next = previous_line->next;
588 previous_line->next = new_line;
589 current_line = new_line;
590 es->line_count++;
591 }
592 else if (current_line->index + delta < current_position - es->text)
593 {
594 /* The previous line merged with this line so we delete this extra entry */
595 previous_line->next = current_line->next;
596 HeapFree(GetProcessHeap(), 0, current_line);
597 current_line = previous_line->next;
598 es->line_count--;
599 continue;
600 }
601 else /* current_line->index + delta == current_position */
602 {
603 if (current_position - es->text > iend)
604 break; /* We reached end of line modifications */
605 /* else recalculate this line */
606 }
607 }
608
609 current_line->index = current_position - es->text;
610 orig_net_length = current_line->net_length;
611
612 /* Find end of line */
613 cp = current_position;
614 while (*cp) {
615 if (*cp == '\n') break;
616 if ((*cp == '\r') && (*(cp + 1) == '\n'))
617 break;
618 cp++;
619 }
620
621 /* Mark type of line termination */
622 if (!(*cp)) {
623 current_line->ending = END_0;
624 current_line->net_length = strlenW(current_position);
625 } else if ((cp > current_position) && (*(cp - 1) == '\r')) {
626 current_line->ending = END_SOFT;
627 current_line->net_length = cp - current_position - 1;
628 } else if (*cp == '\n') {
629 current_line->ending = END_RICH;
630 current_line->net_length = cp - current_position;
631 } else {
632 current_line->ending = END_HARD;
633 current_line->net_length = cp - current_position;
634 }
635
636 if (current_line->net_length)
637 {
638 const SIZE *sz;
641 if (current_line->ssa)
642 {
643 sz = ScriptString_pSize(current_line->ssa);
644 /* Calculate line width */
645 current_line->width = sz->cx;
646 }
647 else current_line->width = es->char_width * current_line->net_length;
648 }
649 else current_line->width = 0;
650
651 /* FIXME: check here for lines that are too wide even in AUTOHSCROLL (> 32767 ???) */
652
653/* Line breaks just look back from the end and find the next break and try that. */
654
655 if (!(es->style & ES_AUTOHSCROLL)) {
656 if (current_line->width > fw && fw > es->char_width) {
657
658 INT prev, next;
659 int w;
660 const SIZE *sz;
661 float d;
662
663 prev = current_line->net_length - 1;
664 w = current_line->net_length;
665 d = (float)current_line->width/(float)fw;
666 if (d > 1.2f) d -= 0.2f;
667 next = prev/d;
668 if (next >= prev) next = prev-1;
669 do {
670 prev = EDIT_CallWordBreakProc(es, current_position - es->text,
671 next, current_line->net_length, WB_LEFT);
672 current_line->net_length = prev;
675 if (current_line->ssa)
676 sz = ScriptString_pSize(current_line->ssa);
677 else sz = 0;
678 if (sz)
679 current_line->width = sz->cx;
680 else
681 prev = 0;
682 next = prev - 1;
683 } while (prev && current_line->width > fw);
684 current_line->net_length = w;
685
686 if (prev == 0) { /* Didn't find a line break so force a break */
687 INT *piDx;
688 const INT *count;
689
692
693 if (current_line->ssa)
694 {
695 count = ScriptString_pcOutChars(current_line->ssa);
696 piDx = HeapAlloc(GetProcessHeap(),0,sizeof(INT) * (*count));
697 ScriptStringGetLogicalWidths(current_line->ssa,piDx);
698
699 prev = current_line->net_length-1;
700 do {
701 current_line->width -= piDx[prev];
702 prev--;
703 } while ( prev > 0 && current_line->width > fw);
704 if (prev<=0)
705 prev = 1;
706 HeapFree(GetProcessHeap(),0,piDx);
707 }
708 else
709 prev = (fw / es->char_width);
710 }
711
712 /* If the first line we are calculating, wrapped before istart, we must
713 * adjust istart in order for this to be reflected in the update region. */
714 if (current_line->index == nstart_index && istart > current_line->index + prev)
715 istart = current_line->index + prev;
716 /* else if we are updating the previous line before the first line we
717 * are re-calculating and it expanded */
718 else if (current_line == start_line &&
719 current_line->index != nstart_index && orig_net_length < prev)
720 {
721 /* Line expanded due to an upwards line wrap so we must partially include
722 * previous line in update region */
723 nstart_line = line_index;
724 nstart_index = current_line->index;
725 istart = current_line->index + orig_net_length;
726 }
727
728 current_line->net_length = prev;
729 current_line->ending = END_WRAP;
730
731 if (current_line->net_length > 0)
732 {
734 if (current_line->ssa)
735 {
736 sz = ScriptString_pSize(current_line->ssa);
737 current_line->width = sz->cx;
738 }
739 else
740 current_line->width = 0;
741 }
742 else current_line->width = 0;
743 }
744 else if (current_line == start_line &&
745 current_line->index != nstart_index &&
746 orig_net_length < current_line->net_length) {
747 /* The previous line expanded but it's still not as wide as the client rect */
748 /* The expansion is due to an upwards line wrap so we must partially include
749 it in the update region */
750 nstart_line = line_index;
751 nstart_index = current_line->index;
752 istart = current_line->index + orig_net_length;
753 }
754 }
755
756
757 /* Adjust length to include line termination */
758 switch (current_line->ending) {
759 case END_SOFT:
760 current_line->length = current_line->net_length + 3;
761 break;
762 case END_RICH:
763 current_line->length = current_line->net_length + 1;
764 break;
765 case END_HARD:
766 current_line->length = current_line->net_length + 2;
767 break;
768 case END_WRAP:
769 case END_0:
770 current_line->length = current_line->net_length;
771 break;
772 }
773 es->text_width = max(es->text_width, current_line->width);
774 current_position += current_line->length;
775 previous_line = current_line;
776
777 /* Discard data for non-visible lines. It will be calculated as needed */
778 if ((line_index < es->y_offset) || (line_index > es->y_offset + vlc))
780
781 current_line = current_line->next;
782 line_index++;
783 } while (previous_line->ending != END_0);
784
785 /* Finish adjusting line indexes by delta or remove hanging lines */
786 if (previous_line->ending == END_0)
787 {
788 LINEDEF *pnext = NULL;
789
790 previous_line->next = NULL;
791 while (current_line)
792 {
793 pnext = current_line->next;
795 HeapFree(GetProcessHeap(), 0, current_line);
796 current_line = pnext;
797 es->line_count--;
798 }
799 }
800 else if (delta != 0)
801 {
802 while (current_line)
803 {
804 current_line->index += delta;
805 current_line = current_line->next;
806 }
807 }
808
809 /* Calculate rest of modification rectangle */
810 if (hrgn)
811 {
812 HRGN tmphrgn;
813 /*
814 * We calculate two rectangles. One for the first line which may have
815 * an indent with respect to the format rect. The other is a format-width
816 * rectangle that spans the rest of the lines that changed or moved.
817 */
818 rc.top = es->format_rect.top + nstart_line * es->line_height -
819 (es->y_offset * es->line_height); /* Adjust for vertical scrollbar */
820 rc.bottom = rc.top + es->line_height;
821 if ((es->style & ES_CENTER) || (es->style & ES_RIGHT))
822 rc.left = es->format_rect.left;
823 else
824#ifdef __REACTOS__ /* CORE-11475 */
825 rc.left = (short)LOWORD(EDIT_EM_PosFromChar(es, nstart_index, FALSE));
826#else
827 rc.left = LOWORD(EDIT_EM_PosFromChar(es, nstart_index, FALSE));
828#endif
829 rc.right = es->format_rect.right;
830 SetRectRgn(hrgn, rc.left, rc.top, rc.right, rc.bottom);
831
832 rc.top = rc.bottom;
833 rc.left = es->format_rect.left;
834 rc.right = es->format_rect.right;
835 /*
836 * If lines were added or removed we must re-paint the remainder of the
837 * lines since the remaining lines were either shifted up or down.
838 */
839 if (line_count < es->line_count) /* We added lines */
840 rc.bottom = es->line_count * es->line_height;
841 else if (line_count > es->line_count) /* We removed lines */
842 rc.bottom = line_count * es->line_height;
843 else
844 rc.bottom = line_index * es->line_height;
845 rc.bottom += es->format_rect.top;
846 rc.bottom -= (es->y_offset * es->line_height); /* Adjust for vertical scrollbar */
847 tmphrgn = CreateRectRgn(rc.left, rc.top, rc.right, rc.bottom);
848 CombineRgn(hrgn, hrgn, tmphrgn, RGN_OR);
849 DeleteObject(tmphrgn);
850 }
static HRGN hrgn
#define FIXME(fmt,...)
Definition: precomp.h:53
#define FALSE
Definition: types.h:117
static void EDIT_InvalidateUniscribeData_linedef(LINEDEF *line_def)
Definition: edit.c:308
static SCRIPT_STRING_ANALYSIS EDIT_UpdateUniscribeData_linedef(EDITSTATE *es, HDC dc, LINEDEF *line_def)
Definition: edit.c:332
static LRESULT EDIT_EM_PosFromChar(EDITSTATE *es, INT index, BOOL after_wrap)
Definition: edit.c:1015
static INT EDIT_CallWordBreakProc(EDITSTATE *es, INT start, INT index, INT count, INT action)
Definition: edit.c:296
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
const WCHAR * text
Definition: package.c:1799
HRESULT WINAPI ScriptStringGetLogicalWidths(SCRIPT_STRING_ANALYSIS ssa, int *piDx)
Definition: usp10.c:3804
const SIZE *WINAPI ScriptString_pSize(SCRIPT_STRING_ANALYSIS ssa)
Definition: usp10.c:3876
const int *WINAPI ScriptString_pcOutChars(SCRIPT_STRING_ANALYSIS ssa)
Definition: usp10.c:3938
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
pKey DeleteObject()
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLuint index
Definition: glext.h:6031
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
#define d
Definition: ke_i.h:81
POINT cp
Definition: magnifier.c:59
static float(__cdecl *square_half_float)(float x
#define LOWORD(l)
Definition: pedump.c:82
#define ES_CENTER
Definition: pedump.c:665
#define ES_RIGHT
Definition: pedump.c:666
static unsigned __int64 next
Definition: rand_nt.c:6
#define strlenW(s)
Definition: unicode.h:34
LONG cx
Definition: kdterminal.h:27
INT width
Definition: edit.c:94
struct tagLINEDEF * next
Definition: edit.c:97
INT length
Definition: edit.c:91
SCRIPT_STRING_ANALYSIS ssa
Definition: edit.c:96
INT index
Definition: edit.c:95
INT net_length
Definition: edit.c:92
LINE_END ending
Definition: edit.c:93
LONG right
Definition: windef.h:308
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
HRGN WINAPI CreateRectRgn(_In_ int, _In_ int, _In_ int, _In_ int)
int WINAPI CombineRgn(_In_opt_ HRGN hrgnDest, _In_opt_ HRGN hrgnSrc1, _In_opt_ HRGN hrgnSrc2, _In_ int fnCombineMode)
#define RGN_OR
Definition: wingdi.h:359
BOOL WINAPI SetRectRgn(_In_ HRGN, _In_ int, _In_ int, _In_ int, _In_ int)
#define WB_LEFT
Definition: winuser.h:550
WCHAR * LPWSTR
Definition: xmlstorage.h:184

◆ EDIT_CalcLineWidth_SL()

static void EDIT_CalcLineWidth_SL ( EDITSTATE es)
static

Definition at line 857 of file edit.c.

859{
861 if (es->ssa)
862 {
863 const SIZE *size;
864 size = ScriptString_pSize(es->ssa);
865 es->text_width = size->cx;
866 }
867 else
868 es->text_width = 0;
static SCRIPT_STRING_ANALYSIS EDIT_UpdateUniscribeData(EDITSTATE *es, HDC dc, INT line)
Definition: edit.c:374
GLsizeiptr size
Definition: glext.h:5919

◆ EDIT_CallWordBreakProc()

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

Definition at line 343 of file edit.c.

345{
346 INT ret;
347
348 if (es->word_break_proc)
349 {
350 if(es->is_unicode)
351 {
352 EDITWORDBREAKPROCW wbpW = (EDITWORDBREAKPROCW)es->word_break_proc;
353
354 TRACE_(relay)("(UNICODE wordbrk=%p,str=%s,idx=%d,cnt=%d,act=%d)\n",
355 es->word_break_proc, debugstr_wn(es->text + start, count), index, count, action);
356 ret = wbpW(es->text + start, index, count, action);
357 }
358 else
359 {
360 EDITWORDBREAKPROCA wbpA = (EDITWORDBREAKPROCA)es->word_break_proc;
361 INT countA;
362 CHAR *textA;
363
364 countA = WideCharToMultiByte(CP_ACP, 0, es->text + start, count, NULL, 0, NULL, NULL);
365 textA = HeapAlloc(GetProcessHeap(), 0, countA);
366#ifdef __REACTOS__
367 /* ReactOS r33503 */
368 if (textA == NULL) return 0;
369#endif
370 WideCharToMultiByte(CP_ACP, 0, es->text + start, count, textA, countA, NULL, NULL);
371 TRACE_(relay)("(ANSI wordbrk=%p,str=%s,idx=%d,cnt=%d,act=%d)\n",
372 es->word_break_proc, debugstr_an(textA, countA), index, countA, action);
373 ret = wbpA(textA, index, countA, action);
375 }
376 }
377 else
379
380 return ret;
#define index(s, c)
Definition: various.h:29
static INT EDIT_WordBreakProc(EDITSTATE *es, LPWSTR s, INT index, INT count, INT action)
Definition: edit.c:238
#define CP_ACP
Definition: compat.h:109
#define TRACE_(x)
Definition: compat.h:76
static __inline const char * debugstr_an(const char *s, int n)
Definition: compat.h:55
#define WideCharToMultiByte
Definition: compat.h:111
const WCHAR * action
Definition: action.c:7479
GLuint start
Definition: gl.h:1545
#define debugstr_wn
Definition: kernel32.h:33
static const char textA[]
Definition: registrar.c:40
int ret
int(CALLBACK * EDITWORDBREAKPROCA)(LPSTR, int, int, int)
Definition: winuser.h:2904
int(CALLBACK * EDITWORDBREAKPROCW)(LPWSTR, int, int, int)
Definition: winuser.h:2905
char CHAR
Definition: xmlstorage.h:175

◆ EDIT_CharFromPos()

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

Definition at line 880 of file edit.c.

882{
883 INT index;
884
885 if (es->style & ES_MULTILINE) {
886 int trailing;
887 INT line = (y - es->format_rect.top) / es->line_height + es->y_offset;
888 INT line_index = 0;
889 LINEDEF *line_def = es->first_line_def;
891 while ((line > 0) && line_def->next) {
892 line_index += line_def->length;
893 line_def = line_def->next;
894 line--;
895 }
896
897 x += es->x_offset - es->format_rect.left;
898 if (es->style & ES_RIGHT)
899 x -= (es->format_rect.right - es->format_rect.left) - line_def->width;
900 else if (es->style & ES_CENTER)
901 x -= ((es->format_rect.right - es->format_rect.left) - line_def->width) / 2;
902 if (x >= line_def->width) {
903 if (after_wrap)
904 *after_wrap = (line_def->ending == END_WRAP);
905 return line_index + line_def->net_length;
906 }
907 if (x <= 0 || !line_def->ssa) {
908 if (after_wrap)
909 *after_wrap = FALSE;
910 return line_index;
911 }
912
913 ScriptStringXtoCP(line_def->ssa, x , &index, &trailing);
914 if (trailing) index++;
915 index += line_index;
916 if (after_wrap)
917 *after_wrap = ((index == line_index + line_def->net_length) &&
918 (line_def->ending == END_WRAP));
919 } else {
920 INT xoff = 0;
921 INT trailing;
922 if (after_wrap)
923 *after_wrap = FALSE;
924 x -= es->format_rect.left;
925 if (!x)
926 return es->x_offset;
927
928 if (!es->x_offset)
929 {
930 INT indent = (es->format_rect.right - es->format_rect.left) - es->text_width;
931 if (es->style & ES_RIGHT)
932 x -= indent;
933 else if (es->style & ES_CENTER)
934 x -= indent / 2;
935 }
936
938 if (es->x_offset)
939 {
940 if (es->ssa)
941 {
942 if (es->x_offset>= get_text_length(es))
943 {
944 const SIZE *size;
945 size = ScriptString_pSize(es->ssa);
946 xoff = size->cx;
947 }
948 ScriptStringCPtoX(es->ssa, es->x_offset, FALSE, &xoff);
949 }
950 else
951 xoff = 0;
952 }
953 if (x < 0)
954 {
955 if (x + xoff > 0 || !es->ssa)
956 {
957 ScriptStringXtoCP(es->ssa, x+xoff, &index, &trailing);
958 if (trailing) index++;
959 }
960 else
961 index = 0;
962 }
963 else
964 {
965 if (x)
966 {
967 const SIZE *size = NULL;
968 if (es->ssa)
969 size = ScriptString_pSize(es->ssa);
970 if (!size)
971 index = 0;
972 else if (x > size->cx)
974 else if (es->ssa)
975 {
976 ScriptStringXtoCP(es->ssa, x+xoff, &index, &trailing);
977 if (trailing) index++;
978 }
979 else
980 index = 0;
981 }
982 else
983 index = es->x_offset;
984 }
985 }
986 return index;
static const WCHAR indent[]
Definition: object.c:1156
HRESULT WINAPI ScriptStringXtoCP(SCRIPT_STRING_ANALYSIS ssa, int iX, int *piCh, int *piTrailing)
Definition: usp10.c:2474
HRESULT WINAPI ScriptStringCPtoX(SCRIPT_STRING_ANALYSIS ssa, int icp, BOOL fTrailing, int *pX)
Definition: usp10.c:2411
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
if(dx< 0)
Definition: linetemp.h:194
Definition: parser.c:49

◆ EDIT_CheckCombo()

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

Definition at line 3503 of file edit.c.

3505{
3506 HWND hLBox = es->hwndListBox;
3507 HWND hCombo;
3508 BOOL bDropped;
3509 int nEUI;
3510
3511 if (!hLBox)
3512 return FALSE;
3513
3514 hCombo = GetParent(es->hwndSelf);
3515 bDropped = TRUE;
3516 nEUI = 0;
3517
3518 TRACE_(combo)("[%p]: handling msg %x (%x)\n", es->hwndSelf, msg, key);
3519
3520 if (key == VK_UP || key == VK_DOWN)
3521 {
3522 if (SendMessageW(hCombo, CB_GETEXTENDEDUI, 0, 0))
3523 nEUI = 1;
3524
3525 if (msg == WM_KEYDOWN || nEUI)
3526 bDropped = (BOOL)SendMessageW(hCombo, CB_GETDROPPEDSTATE, 0, 0);
3527 }
3528
3529 switch (msg)
3530 {
3531 case WM_KEYDOWN:
3532 if (!bDropped && nEUI && (key == VK_UP || key == VK_DOWN))
3533 {
3534 /* make sure ComboLBox pops up */
3535 SendMessageW(hCombo, CB_SETEXTENDEDUI, FALSE, 0);
3536 key = VK_F4;
3537 nEUI = 2;
3538 }
3539
3540 SendMessageW(hLBox, WM_KEYDOWN, key, 0);
3541 break;
3542
3543 case WM_SYSKEYDOWN: /* Handle Alt+up/down arrows */
3544 if (nEUI)
3545 SendMessageW(hCombo, CB_SHOWDROPDOWN, !bDropped, 0);
3546 else
3547 SendMessageW(hLBox, WM_KEYDOWN, VK_F4, 0);
3548 break;
3549 }
3550
3551 if(nEUI == 2)
3552 SendMessageW(hCombo, CB_SETEXTENDEDUI, TRUE, 0);
3553
3554 return TRUE;
#define TRUE
Definition: types.h:120
unsigned int BOOL
Definition: ntddk_ex.h:94
#define BOOL
Definition: nt_native.h:43
Definition: copy.c:22
#define CB_SHOWDROPDOWN
Definition: winuser.h:1970
#define VK_UP
Definition: winuser.h:2225
#define VK_F4
Definition: winuser.h:2258
#define CB_GETDROPPEDSTATE
Definition: winuser.h:1945
HWND WINAPI GetParent(_In_ HWND)
#define CB_GETEXTENDEDUI
Definition: winuser.h:1948
#define VK_DOWN
Definition: winuser.h:2227
#define WM_KEYDOWN
Definition: winuser.h:1715
#define CB_SETEXTENDEDUI
Definition: winuser.h:1964
#define WM_SYSKEYDOWN
Definition: winuser.h:1719
LRESULT WINAPI SendMessageW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)

◆ EDIT_ConfinePoint()

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

Definition at line 997 of file edit.c.

999{
1000 *x = min(max(*x, es->format_rect.left), es->format_rect.right - 1);
1001 *y = min(max(*y, es->format_rect.top), es->format_rect.bottom - 1);

◆ EDIT_ContextMenuCommand()

static void EDIT_ContextMenuCommand ( EDITSTATE es,
UINT  id 
)
static

Definition at line 3380 of file edit.c.

3382{
3383 switch (id) {
3384 case EM_UNDO:
3385 SendMessageW(es->hwndSelf, WM_UNDO, 0, 0);
3386 break;
3387 case WM_CUT:
3388 SendMessageW(es->hwndSelf, WM_CUT, 0, 0);
3389 break;
3390 case WM_COPY:
3391 SendMessageW(es->hwndSelf, WM_COPY, 0, 0);
3392 break;
3393 case WM_PASTE:
3394 SendMessageW(es->hwndSelf, WM_PASTE, 0, 0);
3395 break;
3396 case WM_CLEAR:
3397 SendMessageW(es->hwndSelf, WM_CLEAR, 0, 0);
3398 break;
3399 case EM_SETSEL:
3400 SendMessageW(es->hwndSelf, EM_SETSEL, 0, -1);
3401 break;
3402 default:
3403 ERR("unknown menu item, please report\n");
3404 break;
3405 }
#define ERR(fmt,...)
Definition: precomp.h:57
#define WM_PASTE
Definition: winuser.h:1863
#define WM_CUT
Definition: winuser.h:1861
#define WM_UNDO
Definition: winuser.h:1865
#define EM_UNDO
Definition: winuser.h:2021
#define EM_SETSEL
Definition: winuser.h:2018
#define WM_COPY
Definition: winuser.h:1862
#define WM_CLEAR
Definition: winuser.h:1864

◆ EDIT_EM_CanUndo()

static BOOL EDIT_EM_CanUndo ( const EDITSTATE es)
inlinestatic

Definition at line 189 of file edit.c.

191{
192 return (es->undo_insert_count || strlenW(es->undo_text));

◆ EDIT_EM_CharFromPos()

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

Definition at line 2515 of file edit.c.

2517{
2518 POINT pt;
2519 RECT rc;
2520 INT index;
2521
2522 pt.x = x;
2523 pt.y = y;
2524 GetClientRect(es->hwndSelf, &rc);
2525 if (!PtInRect(&rc, pt))
2526 return -1;
2527
static INT EDIT_CharFromPos(EDITSTATE *es, INT x, INT y, LPBOOL after_wrap)
Definition: edit.c:786
static INT EDIT_EM_LineFromChar(EDITSTATE *es, INT index)
Definition: edit.c:915
#define pt(x, y)
Definition: drawing.c:79
#define MAKELONG(a, b)
Definition: typedefs.h:249
BOOL WINAPI PtInRect(_In_ LPCRECT, _In_ POINT)

◆ EDIT_EM_EmptyUndoBuffer()

static void EDIT_EM_EmptyUndoBuffer ( EDITSTATE es)
inlinestatic

Definition at line 200 of file edit.c.

202{
203 es->undo_insert_count = 0;
204 *es->undo_text = '\0';

◆ EDIT_EM_FmtLines()

static BOOL EDIT_EM_FmtLines ( EDITSTATE es,
BOOL  add_eol 
)
static

Definition at line 2543 of file edit.c.

2545{
2546 es->flags &= ~EF_USE_SOFTBRK;
2547 if (add_eol) {
2548 es->flags |= EF_USE_SOFTBRK;
2549 FIXME("soft break enabled, not implemented\n");
2550 }
2551 return add_eol;
#define EF_USE_SOFTBRK
Definition: edit.c:76

◆ EDIT_EM_GetHandle()

static HLOCAL EDIT_EM_GetHandle ( EDITSTATE es)
static

Definition at line 2565 of file edit.c.

2567{
2568 HLOCAL hLocal;
2569
2570 if (!(es->style & ES_MULTILINE))
2571 return 0;
2572
2573 if(es->is_unicode)
2574 hLocal = es->hloc32W;
2575 else
2576 {
2577 if(!es->hloc32A)
2578 {
2579 CHAR *textA;
2580 UINT countA, alloc_size;
2581 TRACE("Allocating 32-bit ANSI alias buffer\n");
2582 countA = WideCharToMultiByte(CP_ACP, 0, es->text, -1, NULL, 0, NULL, NULL);
2583 alloc_size = ROUND_TO_GROW(countA);
2584 if(!(es->hloc32A = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, alloc_size)))
2585 {
2586 ERR("Could not allocate %d bytes for 32-bit ANSI alias buffer\n", alloc_size);
2587 return 0;
2588 }
2589 textA = LocalLock(es->hloc32A);
2590 WideCharToMultiByte(CP_ACP, 0, es->text, -1, textA, countA, NULL, NULL);
2591 LocalUnlock(es->hloc32A);
2592 }
2593 hLocal = es->hloc32A;
2594 }
2595
2597
2598 /* The text buffer handle belongs to the app */
2599 es->hlocapp = hLocal;
2600
2601 TRACE("Returning %p, LocalSize() = %ld\n", hLocal, LocalSize(hLocal));
2602 return hLocal;
#define ROUND_TO_GROW(size)
Definition: edit.c:64
static void EDIT_UnlockBuffer(EDITSTATE *es, BOOL force)
Definition: edit.c:1228
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
LPVOID NTAPI LocalLock(HLOCAL hMem)
Definition: heapmem.c:1616
BOOL NTAPI LocalUnlock(HLOCAL hMem)
Definition: heapmem.c:1805
SIZE_T NTAPI LocalSize(HLOCAL hMem)
Definition: heapmem.c:1794
unsigned int UINT
Definition: ndis.h:50
#define TRACE(s)
Definition: solgame.cpp:4
#define LMEM_MOVEABLE
Definition: winbase.h:369
#define LMEM_ZEROINIT
Definition: winbase.h:375

◆ EDIT_EM_GetLine()

static INT EDIT_EM_GetLine ( EDITSTATE es,
INT  line,
LPWSTR  dst,
BOOL  unicode 
)
static

Definition at line 2610 of file edit.c.

2612{
2613 LPWSTR src;
2614 INT line_len, dst_len;
2615 INT i;
2616
2617 if (es->style & ES_MULTILINE) {
2618 if (line >= es->line_count)
2619 return 0;
2620 } else
2621 line = 0;
2623 src = es->text + i;
2624 line_len = EDIT_EM_LineLength(es, i);
2625 dst_len = *(WORD *)dst;
2626 if(unicode)
2627 {
2628 if(dst_len <= line_len)
2629 {
2630 memcpy(dst, src, dst_len * sizeof(WCHAR));
2631 return dst_len;
2632 }
2633 else /* Append 0 if enough space */
2634 {
2635 memcpy(dst, src, line_len * sizeof(WCHAR));
2636 dst[line_len] = 0;
2637 return line_len;
2638 }
2639 }
2640 else
2641 {
2642 INT ret = WideCharToMultiByte(CP_ACP, 0, src, line_len, (LPSTR)dst, dst_len, NULL, NULL);
2643 if(!ret && line_len) /* Insufficient buffer size */
2644 return dst_len;
2645 if(ret < dst_len) /* Append 0 if enough space */
2646 ((LPSTR)dst)[ret] = 0;
2647 return ret;
2648 }
static INT EDIT_EM_LineIndex(const EDITSTATE *es, INT line)
Definition: edit.c:944
static INT EDIT_EM_LineLength(EDITSTATE *es, INT index)
Definition: edit.c:979
unsigned short WORD
Definition: ntddk_ex.h:93
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
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
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ EDIT_EM_GetSel()

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

Definition at line 2656 of file edit.c.

2658{
2659 UINT s = es->selection_start;
2660 UINT e = es->selection_end;
2661
2662 ORDER_UINT(s, e);
2663 if (start)
2664 *start = s;
2665 if (end)
2666 *end = e;
2667 return MAKELONG(s, e);
#define ORDER_UINT(x, y)
Definition: edit.c:166
GLdouble s
Definition: gl.h:2039
GLuint GLuint end
Definition: gl.h:1545
#define e
Definition: ke_i.h:82

◆ EDIT_EM_GetThumb()

static LRESULT EDIT_EM_GetThumb ( EDITSTATE es)
static

Definition at line 4480 of file edit.c.

4482{
static LRESULT EDIT_WM_HScroll(EDITSTATE *es, INT action, INT pos)
Definition: edit.c:4008
static LRESULT EDIT_WM_VScroll(EDITSTATE *es, INT action, INT pos)
Definition: edit.c:4140
#define EM_GETTHUMB
Definition: winuser.h:1998

◆ EDIT_EM_LineFromChar()

static INT EDIT_EM_LineFromChar ( EDITSTATE es,
INT  index 
)
static

Definition at line 1009 of file edit.c.

1011{
1012 INT line;
1013 LINEDEF *line_def;
1014
1015 if (!(es->style & ES_MULTILINE))
1016 return 0;
1017 if (index > (INT)get_text_length(es))
1018 return es->line_count - 1;
1019 if (index == -1)
1020 index = min(es->selection_start, es->selection_end);
1021
1022 line = 0;
1023 line_def = es->first_line_def;
1024 index -= line_def->length;
1025 while ((index >= 0) && line_def->next) {
1026 line++;
1027 line_def = line_def->next;
1028 index -= line_def->length;
1029 }
1030 return line;

◆ EDIT_EM_LineIndex()

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

Definition at line 1038 of file edit.c.

1040{
1041 INT line_index;
1042 const LINEDEF *line_def;
1043
1044 if (!(es->style & ES_MULTILINE))
1045 return 0;
1046 if (line >= es->line_count)
1047 return -1;
1048
1049 line_index = 0;
1050 line_def = es->first_line_def;
1051 if (line == -1) {
1052 INT index = es->selection_end - line_def->length;
1053 while ((index >= 0) && line_def->next) {
1054 line_index += line_def->length;
1055 line_def = line_def->next;
1056 index -= line_def->length;
1057 }
1058 } else {
1059 while (line > 0) {
1060 line_index += line_def->length;
1061 line_def = line_def->next;
1062 line--;
1063 }
1064 }
1065 return line_index;

◆ EDIT_EM_LineLength()

static INT EDIT_EM_LineLength ( EDITSTATE es,
INT  index 
)
static

Definition at line 1073 of file edit.c.

1075{
1076 LINEDEF *line_def;
1077
1078 if (!(es->style & ES_MULTILINE))
1079 return get_text_length(es);
1080
1081 if (index == -1) {
1082 /* get the number of remaining non-selected chars of selected lines */
1083 INT32 l; /* line number */
1084 INT32 li; /* index of first char in line */
1085 INT32 count;
1086 l = EDIT_EM_LineFromChar(es, es->selection_start);
1087 /* # chars before start of selection area */
1088 count = es->selection_start - EDIT_EM_LineIndex(es, l);
1089 l = EDIT_EM_LineFromChar(es, es->selection_end);
1090 /* # chars after end of selection */
1092 count += li + EDIT_EM_LineLength(es, li) - es->selection_end;
1093 return count;
1094 }
1095 line_def = es->first_line_def;
1096 index -= line_def->length;
1097 while ((index >= 0) && line_def->next) {
1098 line_def = line_def->next;
1099 index -= line_def->length;
1100 }
1101 return line_def->net_length;
signed int INT32
r l[0]
Definition: byte_order.h:168
LARGE_INTEGER li
Definition: fxtimerapi.cpp:235

◆ EDIT_EM_LineScroll()

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

Definition at line 1809 of file edit.c.

1811{
1812 if (!(es->style & ES_MULTILINE))
1813 return FALSE;
1814
1815 dx *= es->char_width;
static BOOL EDIT_EM_LineScroll_internal(EDITSTATE *es, INT dx, INT dy)
Definition: edit.c:1599
GLint dy
Definition: linetemp.h:97
GLint dx
Definition: linetemp.h:97

◆ EDIT_EM_LineScroll_internal()

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

Definition at line 1753 of file edit.c.

1755{
1756 INT nyoff;
1757 INT x_offset_in_pixels;
1758 INT lines_per_page = (es->format_rect.bottom - es->format_rect.top) /
1759 es->line_height;
1760
1761 if (es->style & ES_MULTILINE)
1762 {
1763 x_offset_in_pixels = es->x_offset;
1764 }
1765 else
1766 {
1767 dy = 0;
1768 x_offset_in_pixels = (short)LOWORD(EDIT_EM_PosFromChar(es, es->x_offset, FALSE));
1769 }
1770
1771 if (-dx > x_offset_in_pixels)
1772 dx = -x_offset_in_pixels;
1773 if (dx > es->text_width - x_offset_in_pixels)
1774 dx = es->text_width - x_offset_in_pixels;
1775 nyoff = max(0, es->y_offset + dy);
1776 if (nyoff >= es->line_count - lines_per_page)
1777 nyoff = max(0, es->line_count - lines_per_page);
1778 dy = (es->y_offset - nyoff) * es->line_height;
1779 if (dx || dy) {
1780 RECT rc1;
1781 RECT rc;
1782
1783 es->y_offset = nyoff;
1784 if(es->style & ES_MULTILINE)
1785 es->x_offset += dx;
1786 else
1787 es->x_offset += dx / es->char_width;
1788
1789 GetClientRect(es->hwndSelf, &rc1);
1790 IntersectRect(&rc, &rc1, &es->format_rect);
1791 ScrollWindowEx(es->hwndSelf, -dx, dy,
1792 NULL, &rc, NULL, NULL, SW_INVALIDATE);
1793 /* force scroll info update */
1795 }
1796 if (dx && !(es->flags & EF_HSCROLL_TRACK))
1798 if (dy && !(es->flags & EF_VSCROLL_TRACK))
1800 return TRUE;
static BOOL notify_parent(const EDITSTATE *es, INT code)
Definition: edit.c:168
#define EF_HSCROLL_TRACK
Definition: edit.c:74
#define EF_VSCROLL_TRACK
Definition: edit.c:73
#define SW_INVALIDATE
Definition: winuser.h:2579
#define EN_HSCROLL
Definition: winuser.h:2024
BOOL WINAPI IntersectRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
#define EN_VSCROLL
Definition: winuser.h:2029
int WINAPI ScrollWindowEx(_In_ HWND, _In_ int, _In_ int, _In_opt_ LPCRECT, _In_opt_ LPCRECT, _In_opt_ HRGN, _Out_opt_ LPRECT, _In_ UINT)

◆ EDIT_EM_PosFromChar()

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

Definition at line 1109 of file edit.c.

1111{
1113 INT l;
1114 INT li;
1115 INT x = 0;
1116 INT y = 0;
1117 INT w;
1118 INT lw;
1119 LINEDEF *line_def;
1120
1121 index = min(index, len);
1122 if (es->style & ES_MULTILINE) {
1125
1126 y = (l - es->y_offset) * es->line_height;
1128 if (after_wrap && (li == index) && l) {
1129 INT l2 = l - 1;
1130 line_def = es->first_line_def;
1131 while (l2) {
1132 line_def = line_def->next;
1133 l2--;
1134 }
1135 if (line_def->ending == END_WRAP) {
1136 l--;
1137 y -= es->line_height;
1139 }
1140 }
1141
1142 line_def = es->first_line_def;
1143 while (line_def->index != li)
1144 line_def = line_def->next;
1145
1146 lw = line_def->width;
1147 w = es->format_rect.right - es->format_rect.left;
1148 if (line_def->ssa)
1149 {
1150 ScriptStringCPtoX(line_def->ssa, (index - 1) - li, TRUE, &x);
1151 x -= es->x_offset;
1152 }
1153 else
1154#ifdef __REACTOS__ /* CORE-15780 */
1155 x = (lw > 0 ? es->x_offset : x - es->x_offset);
1156#else
1157 x = es->x_offset;
1158#endif
1159
1160 if (es->style & ES_RIGHT)
1161 x = w - (lw - x);
1162 else if (es->style & ES_CENTER)
1163 x += (w - lw) / 2;
1164 } else {
1165 INT xoff = 0;
1166 INT xi = 0;
1168 if (es->x_offset)
1169 {
1170 if (es->ssa)
1171 {
1172 if (es->x_offset >= get_text_length(es))
1173 {
1174 int leftover = es->x_offset - get_text_length(es);
1175 if (es->ssa)
1176 {
1177 const SIZE *size;
1178 size = ScriptString_pSize(es->ssa);
1179 xoff = size->cx;
1180 }
1181 else
1182 xoff = 0;
1183 xoff += es->char_width * leftover;
1184 }
1185 else
1186 ScriptStringCPtoX(es->ssa, es->x_offset, FALSE, &xoff);
1187 }
1188 else
1189 xoff = 0;
1190 }
1191 if (index)
1192 {
1193 if (index >= get_text_length(es))
1194 {
1195 if (es->ssa)
1196 {
1197 const SIZE *size;
1198 size = ScriptString_pSize(es->ssa);
1199 xi = size->cx;
1200 }
1201 else
1202 xi = 0;
1203 }
1204 else if (es->ssa)
1205 ScriptStringCPtoX(es->ssa, index, FALSE, &xi);
1206 else
1207 xi = 0;
1208 }
1209 x = xi - xoff;
1210
1211 if (index >= es->x_offset) {
1212 if (!es->x_offset && (es->style & (ES_RIGHT | ES_CENTER)))
1213 {
1214 w = es->format_rect.right - es->format_rect.left;
1215 if (w > es->text_width)
1216 {
1217 if (es->style & ES_RIGHT)
1218 x += w - es->text_width;
1219 else if (es->style & ES_CENTER)
1220 x += (w - es->text_width) / 2;
1221 }
1222 }
1223 }
1224 y = 0;
1225 }
1226 x += es->format_rect.left;
1227 y += es->format_rect.top;
1228 return MAKELONG((INT16)x, (INT16)y);
signed short INT16
GLenum GLsizei len
Definition: glext.h:6722

◆ EDIT_EM_ReplaceSel()

static void EDIT_EM_ReplaceSel ( EDITSTATE es,
BOOL  can_undo,
LPCWSTR  lpsz_replace,
BOOL  send_update,
BOOL  honor_limit 
)
static

Definition at line 2677 of file edit.c.

2679{
2680 UINT strl = strlenW(lpsz_replace);
2681 UINT tl = get_text_length(es);
2682 UINT utl;
2683 UINT s;
2684 UINT e;
2685 UINT i;
2686 UINT size;
2687 LPWSTR p;
2688 HRGN hrgn = 0;
2689 LPWSTR buf = NULL;
2690 UINT bufl;
2691
2692 TRACE("%s, can_undo %d, send_update %d\n",
2693 debugstr_w(lpsz_replace), can_undo, send_update);
2694
2695 s = es->selection_start;
2696 e = es->selection_end;
2697
2699 if ((s == e) && !strl)
2700 return;
2701
2702 ORDER_UINT(s, e);
2703
2704 size = tl - (e - s) + strl;
2705 if (!size)
2706 es->text_width = 0;
2707
2708 /* Issue the EN_MAXTEXT notification and continue with replacing text
2709 * so that buffer limit is honored. */
2710 if ((honor_limit) && (size > es->buffer_limit))
2711 {
2712 if (!notify_parent(es, EN_MAXTEXT)) return;
2713 /* Buffer limit can be smaller than the actual length of text in combobox */
2714 if (es->buffer_limit < (tl - (e-s)))
2715 strl = 0;
2716 else
2717 strl = min(strl, es->buffer_limit - (tl - (e-s)));
2718 }
2719
2720 if (!EDIT_MakeFit(es, tl - (e - s) + strl))
2721 return;
2722
2723 if (e != s) {
2724 /* there is something to be deleted */
2725 TRACE("deleting stuff.\n");
2726 bufl = e - s;
2727 buf = HeapAlloc(GetProcessHeap(), 0, (bufl + 1) * sizeof(WCHAR));
2728 if (!buf) return;
2729 memcpy(buf, es->text + s, bufl * sizeof(WCHAR));
2730 buf[bufl] = 0; /* ensure 0 termination */
2731 /* now delete */
2732 strcpyW(es->text + s, es->text + e);
2734 }
2735 if (strl) {
2736 /* there is an insertion */
2737 tl = get_text_length(es);
2738 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));
2739 for (p = es->text + tl ; p >= es->text + s ; p--)
2740 p[strl] = p[0];
2741 for (i = 0 , p = es->text + s ; i < strl ; i++)
2742 p[i] = lpsz_replace[i];
2743 if(es->style & ES_UPPERCASE)
2744 CharUpperBuffW(p, strl);
2745 else if(es->style & ES_LOWERCASE)
2746 CharLowerBuffW(p, strl);
2748 }
2749 if (es->style & ES_MULTILINE)
2750 {
2751 INT st = min(es->selection_start, es->selection_end);
2753
2754 hrgn = CreateRectRgn(0, 0, 0, 0);
2755 EDIT_BuildLineDefs_ML(es, st, st + strl,
2756 strl - abs(es->selection_end - es->selection_start), hrgn);
2757 /* if text is too long undo all changes */
2758 if (honor_limit && !(es->style & ES_AUTOVSCROLL) && (es->line_count > vlc)) {
2759 if (strl)
2760 strcpyW(es->text + e, es->text + e + strl);
2761 if (e != s)
2762 for (i = 0 , p = es->text ; i < e - s ; i++)
2763 p[i + s] = buf[i];
2766 abs(es->selection_end - es->selection_start) - strl, hrgn);
2767 strl = 0;
2768 e = s;
2769 SetRectRgn(hrgn, 0, 0, 0, 0);
2770 if (!notify_parent(es, EN_MAXTEXT)) return;
2771 }
2772 }
2773 else {
2774 INT fw = es->format_rect.right - es->format_rect.left;
2777 /* remove chars that don't fit */
2778 if (honor_limit && !(es->style & ES_AUTOHSCROLL) && (es->text_width > fw)) {
2779 while ((es->text_width > fw) && s + strl >= s) {
2780 strcpyW(es->text + s + strl - 1, es->text + s + strl);
2781 strl--;
2782 es->text_length = -1;
2785 }
2787 if (!notify_parent(es, EN_MAXTEXT)) return;
2788 }
2789 }
2790
2791 if (e != s) {
2792 if (can_undo) {
2793 utl = strlenW(es->undo_text);
2794 if (!es->undo_insert_count && (*es->undo_text && (s == es->undo_position))) {
2795 /* undo-buffer is extended to the right */
2796 EDIT_MakeUndoFit(es, utl + e - s);
2797 memcpy(es->undo_text + utl, buf, (e - s)*sizeof(WCHAR));
2798 (es->undo_text + utl)[e - s] = 0; /* ensure 0 termination */
2799 } else if (!es->undo_insert_count && (*es->undo_text && (e == es->undo_position))) {
2800 /* undo-buffer is extended to the left */
2801 EDIT_MakeUndoFit(es, utl + e - s);
2802 for (p = es->undo_text + utl ; p >= es->undo_text ; p--)
2803 p[e - s] = p[0];
2804 for (i = 0 , p = es->undo_text ; i < e - s ; i++)
2805 p[i] = buf[i];
2806 es->undo_position = s;
2807 } else {
2808 /* new undo-buffer */
2809 EDIT_MakeUndoFit(es, e - s);
2810 memcpy(es->undo_text, buf, (e - s)*sizeof(WCHAR));
2811 es->undo_text[e - s] = 0; /* ensure 0 termination */
2812 es->undo_position = s;
2813 }
2814 /* any deletion makes the old insertion-undo invalid */
2815 es->undo_insert_count = 0;
2816 } else
2818 }
2819 if (strl) {
2820 if (can_undo) {
2821 if ((s == es->undo_position) ||
2822 ((es->undo_insert_count) &&
2823 (s == es->undo_position + es->undo_insert_count)))
2824 /*
2825 * insertion is new and at delete position or
2826 * an extension to either left or right
2827 */
2828 es->undo_insert_count += strl;
2829 else {
2830 /* new insertion undo */
2831 es->undo_position = s;
2832 es->undo_insert_count = strl;
2833 /* new insertion makes old delete-buffer invalid */
2834 *es->undo_text = '\0';
2835 }
2836 } else
2838 }
2839
2841
2842 s += strl;
2843
2844 /* If text has been deleted and we're right or center aligned then scroll rightward */
2845 if (es->style & (ES_RIGHT | ES_CENTER))
2846 {
2847 INT delta = strl - abs(es->selection_end - es->selection_start);
2848
2849 if (delta < 0 && es->x_offset)
2850 {
2851 if (abs(delta) > es->x_offset)
2852 es->x_offset = 0;
2853 else
2854 es->x_offset += delta;
2855 }
2856 }
2857
2859 es->flags |= EF_MODIFIED;
2860 if (send_update) es->flags |= EF_UPDATE;
2861 if (hrgn)
2862 {
2865 }
2866 else
2868
2870
2871 /* force scroll info update */
2873
2874
2875 if(send_update || (es->flags & EF_UPDATE))
2876 {
2877 es->flags &= ~EF_UPDATE;
2878 if (!notify_parent(es, EN_CHANGE)) return;
2879 }
#define EF_MODIFIED
Definition: edit.c:70
static void EDIT_CalcLineWidth_SL(EDITSTATE *es)
Definition: edit.c:763
static void EDIT_EM_ScrollCaret(EDITSTATE *es)
Definition: edit.c:1778
#define EF_UPDATE
Definition: edit.c:72
static void EDIT_InvalidateUniscribeData(EDITSTATE *es)
Definition: edit.c:317
static void EDIT_EM_EmptyUndoBuffer(EDITSTATE *es)
Definition: edit.c:194
static void text_buffer_changed(EDITSTATE *es)
Definition: edit.c:1196
static BOOL EDIT_MakeFit(EDITSTATE *es, UINT size)
Definition: edit.c:1274
static BOOL EDIT_MakeUndoFit(EDITSTATE *es, UINT size)
Definition: edit.c:1315
static void EDIT_UpdateTextRegion(EDITSTATE *es, HRGN hrgn, BOOL bErase)
Definition: edit.c:1342
static void EDIT_UpdateText(EDITSTATE *es, const RECT *rc, BOOL bErase)
Definition: edit.c:1357
static BOOL EDIT_EM_SetSel(EDITSTATE *es, UINT start, UINT end, BOOL after_wrap)
Definition: edit.c:1487
#define abs(i)
Definition: fconv.c:206
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLfloat GLfloat p
Definition: glext.h:8902
#define debugstr_w
Definition: kernel32.h:32
#define ES_LOWERCASE
Definition: pedump.c:669
#define ES_AUTOVSCROLL
Definition: pedump.c:671
#define ES_UPPERCASE
Definition: pedump.c:668
#define strcpyW(d, s)
Definition: unicode.h:35
#define EN_MAXTEXT
Definition: winuser.h:2026
DWORD WINAPI CharUpperBuffW(_Inout_updates_(cchLength) LPWSTR lpsz, _In_ DWORD cchLength)
#define EN_CHANGE
Definition: winuser.h:2022
DWORD WINAPI CharLowerBuffW(_Inout_updates_(cchLength) LPWSTR lpsz, _In_ DWORD cchLength)

◆ EDIT_EM_Scroll()

static LRESULT EDIT_EM_Scroll ( EDITSTATE es,
INT  action 
)
static

Definition at line 1824 of file edit.c.

1826{
1827 INT dy;
1828
1829 if (!(es->style & ES_MULTILINE))
1830 return (LRESULT)FALSE;
1831
1832 dy = 0;
1833
1834 switch (action) {
1835 case SB_LINEUP:
1836 if (es->y_offset)
1837 dy = -1;
1838 break;
1839 case SB_LINEDOWN:
1840 if (es->y_offset < es->line_count - 1)
1841 dy = 1;
1842 break;
1843 case SB_PAGEUP:
1844 if (es->y_offset)
1845 dy = -(es->format_rect.bottom - es->format_rect.top) / es->line_height;
1846 break;
1847 case SB_PAGEDOWN:
1848 if (es->y_offset < es->line_count - 1)
1849 dy = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
1850 break;
1851 default:
1853 }
1854 if (dy) {
1856 /* check if we are going to move too far */
1857 if(es->y_offset + dy > es->line_count - vlc)
1858 dy = max(es->line_count - vlc, 0) - es->y_offset;
1859
1860 /* Notification is done in EDIT_EM_LineScroll */
1861 if(dy) {
1863 return MAKELONG(dy, TRUE);
1864 }
1865
1866 }
1867 return (LRESULT)FALSE;
return
Definition: dirsup.c:529
static BOOL EDIT_EM_LineScroll(EDITSTATE *es, INT dx, INT dy)
Definition: edit.c:1655
LONG_PTR LRESULT
Definition: windef.h:209
#define SB_LINEUP
Definition: winuser.h:564
#define SB_PAGEDOWN
Definition: winuser.h:569
#define SB_LINEDOWN
Definition: winuser.h:565
#define SB_PAGEUP
Definition: winuser.h:568

◆ EDIT_EM_ScrollCaret()

static void EDIT_EM_ScrollCaret ( EDITSTATE es)
static

Definition at line 1932 of file edit.c.

1934{
1935 if (es->style & ES_MULTILINE) {
1936 INT l;
1937 INT vlc;
1938 INT ww;
1939 INT cw = es->char_width;
1940 INT x;
1941 INT dy = 0;
1942 INT dx = 0;
1943
1944 l = EDIT_EM_LineFromChar(es, es->selection_end);
1945 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, es->flags & EF_AFTER_WRAP));
1947 if (l >= es->y_offset + vlc)
1948 dy = l - vlc + 1 - es->y_offset;
1949 if (l < es->y_offset)
1950 dy = l - es->y_offset;
1951 ww = es->format_rect.right - es->format_rect.left;
1952 if (x < es->format_rect.left)
1953 dx = x - es->format_rect.left - ww / HSCROLL_FRACTION / cw * cw;
1954 if (x > es->format_rect.right)
1955 dx = x - es->format_rect.left - (HSCROLL_FRACTION - 1) * ww / HSCROLL_FRACTION / cw * cw;
1956 if (dy || dx || (es->y_offset && (es->line_count - es->y_offset < vlc)))
1957 {
1958 /* check if we are going to move too far */
1959 if(es->x_offset + dx + ww > es->text_width)
1960 dx = es->text_width - ww - es->x_offset;
1961 if(dx || dy || (es->y_offset && (es->line_count - es->y_offset < vlc)))
1963 }
1964 } else {
1965 INT x;
1966 INT goal;
1967 INT format_width;
1968
1969 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, FALSE));
1970 format_width = es->format_rect.right - es->format_rect.left;
1971 if (x < es->format_rect.left) {
1972 goal = es->format_rect.left + format_width / HSCROLL_FRACTION;
1973 do {
1974 es->x_offset--;
1975 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, FALSE));
1976 } while ((x < goal) && es->x_offset);
1977 /* FIXME: use ScrollWindow() somehow to improve performance */
1979 } else if (x > es->format_rect.right) {
1980 INT x_last;
1982 goal = es->format_rect.right - format_width / HSCROLL_FRACTION;
1983 do {
1984 es->x_offset++;
1985 x = (short)LOWORD(EDIT_EM_PosFromChar(es, es->selection_end, FALSE));
1987 } while ((x > goal) && (x_last > es->format_rect.right));
1988 /* FIXME: use ScrollWindow() somehow to improve performance */
1990 }
1991 }
1992
1993 if(es->flags & EF_FOCUSED)
1994 EDIT_SetCaretPos(es, es->selection_end, es->flags & EF_AFTER_WRAP);
#define EF_FOCUSED
Definition: edit.c:71
#define HSCROLL_FRACTION
Definition: edit.c:65

◆ EDIT_EM_SetHandle()

static void EDIT_EM_SetHandle ( EDITSTATE es,
HLOCAL  hloc 
)
static

Definition at line 2890 of file edit.c.

2892{
2893 if (!(es->style & ES_MULTILINE))
2894 return;
2895
2896 if (!hloc) {
2897 WARN("called with NULL handle\n");
2898 return;
2899 }
2900
2902
2903 if(es->is_unicode)
2904 {
2905 if(es->hloc32A)
2906 {
2907 LocalFree(es->hloc32A);
2908 es->hloc32A = NULL;
2909 }
2910 es->hloc32W = hloc;
2911 }
2912 else
2913 {
2914 INT countW, countA;
2915 HLOCAL hloc32W_new;
2916 WCHAR *textW;
2917 CHAR *textA;
2918
2919 countA = LocalSize(hloc);
2920 textA = LocalLock(hloc);
2921 countW = MultiByteToWideChar(CP_ACP, 0, textA, countA, NULL, 0);
2922 if(!(hloc32W_new = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, countW * sizeof(WCHAR))))
2923 {
2924 ERR("Could not allocate new unicode buffer\n");
2925 return;
2926 }
2927 textW = LocalLock(hloc32W_new);
2928 MultiByteToWideChar(CP_ACP, 0, textA, countA, textW, countW);
2929 LocalUnlock(hloc32W_new);
2930 LocalUnlock(hloc);
2931
2932 if(es->hloc32W)
2933 LocalFree(es->hloc32W);
2934
2935 es->hloc32W = hloc32W_new;
2936 es->hloc32A = hloc;
2937 }
2938
2939 es->buffer_size = LocalSize(es->hloc32W)/sizeof(WCHAR) - 1;
2940
2941 /* The text buffer handle belongs to the control */
2942 es->hlocapp = NULL;
2943
2946
2947 es->x_offset = es->y_offset = 0;
2948 es->selection_start = es->selection_end = 0;
2950 es->flags &= ~EF_MODIFIED;
2951 es->flags &= ~EF_UPDATE;
2955 /* force scroll info update */
#define WARN(fmt,...)
Definition: precomp.h:61
static void EDIT_LockBuffer(EDITSTATE *es)
Definition: edit.c:1209
#define MultiByteToWideChar
Definition: compat.h:110
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
static const WCHAR textW[]
Definition: itemdlg.c:1559

◆ EDIT_EM_SetLimitText()

static void EDIT_EM_SetLimitText ( EDITSTATE es,
UINT  limit 
)
static

Definition at line 2966 of file edit.c.

2968{
2969 if (!limit) limit = ~0u;
2970 if (!(es->style & ES_MULTILINE)) limit = min(limit, 0x7ffffffe);
2971 es->buffer_limit = limit;
GLint limit
Definition: glext.h:10326
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

◆ EDIT_EM_SetMargins()

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

Definition at line 3002 of file edit.c.

3005{
3007 INT default_left_margin = 0; /* in pixels */
3008 INT default_right_margin = 0; /* in pixels */
3009
3010 /* Set the default margins depending on the font */
3011 if (es->font && (left == EC_USEFONTINFO || right == EC_USEFONTINFO)) {
3012 HDC dc = GetDC(es->hwndSelf);
3013 HFONT old_font = SelectObject(dc, es->font);
3015 RECT rc;
3016
3017 /* The default margins are only non zero for TrueType or Vector fonts */
3018 if (tm.tmPitchAndFamily & ( TMPF_VECTOR | TMPF_TRUETYPE )) {
3019 if (!is_cjk(tm.tmCharSet)) {
3020 default_left_margin = width / 2;
3021 default_right_margin = width / 2;
3022
3023 GetClientRect(es->hwndSelf, &rc);
3024 if (rc.right - rc.left < (width / 2 + width) * 2 &&
3025 (width >= 28 || !IsRectEmpty(&rc)) ) {
3026 default_left_margin = es->left_margin;
3027 default_right_margin = es->right_margin;
3028 }
3029 } else {
3030 /* FIXME: figure out the CJK values. They are not affected by the client rect. */
3031 default_left_margin = width / 2;
3032 default_right_margin = width / 2;
3033 }
3034 }
3035 SelectObject(dc, old_font);
3036 ReleaseDC(es->hwndSelf, dc);
3037 }
3038
3039 if (action & EC_LEFTMARGIN) {
3040 es->format_rect.left -= es->left_margin;
3041 if (left != EC_USEFONTINFO)
3042 es->left_margin = left;
3043 else
3044 es->left_margin = default_left_margin;
3045 es->format_rect.left += es->left_margin;
3046 }
3047
3048 if (action & EC_RIGHTMARGIN) {
3049 es->format_rect.right += es->right_margin;
3050 if (right != EC_USEFONTINFO)
3051 es->right_margin = right;
3052 else
3053 es->right_margin = default_right_margin;
3054 es->format_rect.right -= es->right_margin;
3055 }
3056
3059 if (repaint) EDIT_UpdateText(es, NULL, TRUE);
3060 }
3061
3062 TRACE("left=%d, right=%d\n", es->left_margin, es->right_margin);
static void EDIT_AdjustFormatRect(EDITSTATE *es)
Definition: edit.c:2261
GLint GLint GLsizei width
Definition: gl.h:1546
GLdouble GLdouble right
Definition: glext.h:10859
GLint left
Definition: glext.h:7726
static const WCHAR dc[]
static HDC
Definition: imagelist.c:92
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
static BOOL is_cjk(void)
Definition: dde.c:46
long LONG
Definition: pedump.c:60
Definition: time.h:68
LONG WINAPI GdiGetCharDimensions(HDC, LPTEXTMETRICW, LONG *)
Definition: font.c:2145
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1546
#define TMPF_TRUETYPE
Definition: wingdi.h:1313
#define TMPF_VECTOR
Definition: wingdi.h:1312
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
#define EC_RIGHTMARGIN
Definition: winuser.h:2607
#define EC_USEFONTINFO
Definition: winuser.h:2608
BOOL WINAPI IsRectEmpty(_In_ LPCRECT)
HDC WINAPI GetDC(_In_opt_ HWND)
#define EC_LEFTMARGIN
Definition: winuser.h:2606

◆ EDIT_EM_SetPasswordChar()

static void EDIT_EM_SetPasswordChar ( EDITSTATE es,
WCHAR  c 
)
static

Definition at line 3070 of file edit.c.

3072{
3073 LONG style;
3074
3075 if (es->style & ES_MULTILINE)
3076 return;
3077
3078 if (es->password_char == c)
3079 return;
3080
3081 style = GetWindowLongW( es->hwndSelf, GWL_STYLE );
3082 es->password_char = c;
3083 if (c) {
3084 SetWindowLongW( es->hwndSelf, GWL_STYLE, style | ES_PASSWORD );
3085 es->style |= ES_PASSWORD;
3086 } else {
3087 SetWindowLongW( es->hwndSelf, GWL_STYLE, style & ~ES_PASSWORD );
3088 es->style &= ~ES_PASSWORD;
3089 }
Arabic default style
Definition: afstyles.h:94
const GLubyte * c
Definition: glext.h:8905
#define c
Definition: ke_i.h:80
#define ES_PASSWORD
Definition: pedump.c:670
LONG WINAPI SetWindowLongW(_In_ HWND, _In_ int, _In_ LONG)
LONG WINAPI GetWindowLongW(_In_ HWND, _In_ int)
#define GWL_STYLE
Definition: winuser.h:852

◆ EDIT_EM_SetSel()

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

Definition at line 1646 of file edit.c.

1648{
1649 UINT old_start = es->selection_start;
1650 UINT old_end = es->selection_end;
1652
1653 if (start == (UINT)-1) {
1654 start = es->selection_end;
1655 end = es->selection_end;
1656 } else {
1657 start = min(start, len);
1658 end = min(end, len);
1659 }
1660 es->selection_start = start;
1661 es->selection_end = end;
1662 if (after_wrap)
1663 es->flags |= EF_AFTER_WRAP;
1664 else
1665 es->flags &= ~EF_AFTER_WRAP;
1666 /* Compute the necessary invalidation region. */
1667 /* Note that we don't need to invalidate regions which have
1668 * "never" been selected, or those which are "still" selected.
1669 * In fact, every time we hit a selection boundary, we can
1670 * *toggle* whether we need to invalidate. Thus we can optimize by
1671 * *sorting* the interval endpoints. Let's assume that we sort them
1672 * in this order:
1673 * start <= end <= old_start <= old_end
1674 * Knuth 5.3.1 (p 183) assures us that this can be done optimally
1675 * in 5 comparisons; i.e. it is impossible to do better than the
1676 * following: */
1677 ORDER_UINT(end, old_end);
1678 ORDER_UINT(start, old_start);
1679 ORDER_UINT(old_start, old_end);
1681 /* Note that at this point 'end' and 'old_start' are not in order, but
1682 * start is definitely the min. and old_end is definitely the max. */
1683 if (end != old_start)
1684 {
1685/*
1686 * One can also do
1687 * ORDER_UINT32(end, old_start);
1688 * EDIT_InvalidateText(es, start, end);
1689 * EDIT_InvalidateText(es, old_start, old_end);
1690 * in place of the following if statement.
1691 * (That would complete the optimal five-comparison four-element sort.)
1692 */
1693 if (old_start > end )
1694 {
1696 EDIT_InvalidateText(es, old_start, old_end);
1697 }
1698 else
1699 {
1700 EDIT_InvalidateText(es, start, old_start);
1701 EDIT_InvalidateText(es, end, old_end);
1702 }
1703 }
1704 else EDIT_InvalidateText(es, start, old_end);
static void EDIT_InvalidateText(EDITSTATE *es, INT start, INT end)
Definition: edit.c:1457

◆ EDIT_EM_SetTabStops()

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

Definition at line 3099 of file edit.c.

3101{
3102 if (!(es->style & ES_MULTILINE))
3103 return FALSE;
3104 HeapFree(GetProcessHeap(), 0, es->tabs);
3105 es->tabs_count = count;
3106 if (!count)
3107 es->tabs = NULL;
3108 else {
3109 es->tabs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(INT));
3110#ifdef __REACTOS__
3111 /* ReactOS r33503 */
3112 if (es->tabs == NULL)
3113 {
3114 es->tabs_count = 0;
3115 return FALSE;
3116 }
3117#endif
3118 memcpy(es->tabs, tabs, count * sizeof(INT));
3119 }
3121 return TRUE;

◆ EDIT_EM_SetWordBreakProc()

static void EDIT_EM_SetWordBreakProc ( EDITSTATE es,
void wbp 
)
static

Definition at line 3129 of file edit.c.

3131{
3132 if (es->word_break_proc == wbp)
3133 return;
3134
3135 es->word_break_proc = wbp;
3136
3137 if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL)) {
3140 }

◆ EDIT_EM_Undo()

static BOOL EDIT_EM_Undo ( EDITSTATE es)
static

Definition at line 3148 of file edit.c.

3150{
3151 INT ulength;
3152 LPWSTR utext;
3153
3154 /* As per MSDN spec, for a single-line edit control,
3155 the return value is always TRUE */
3156 if( es->style & ES_READONLY )
3157 return !(es->style & ES_MULTILINE);
3158
3159 ulength = strlenW(es->undo_text);
3160
3161 utext = HeapAlloc(GetProcessHeap(), 0, (ulength + 1) * sizeof(WCHAR));
3162#ifdef __REACTOS__
3163 /* ReactOS r33503 */
3164 if (utext == NULL)
3165 return FALSE;
3166#endif
3167
3168 strcpyW(utext, es->undo_text);
3169
3170 TRACE("before UNDO:insertion length = %d, deletion buffer = %s\n",
3171 es->undo_insert_count, debugstr_w(utext));
3172
3173 EDIT_EM_SetSel(es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
3175 EDIT_EM_ReplaceSel(es, TRUE, utext, TRUE, TRUE);
3176 EDIT_EM_SetSel(es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
3177 /* send the notification after the selection start and end are set */
3178 if (!notify_parent(es, EN_CHANGE)) return TRUE;
3180 HeapFree(GetProcessHeap(), 0, utext);
3181
3182 TRACE("after UNDO:insertion length = %d, deletion buffer = %s\n",
3183 es->undo_insert_count, debugstr_w(es->undo_text));
3184 return TRUE;
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:2485
#define ES_READONLY
Definition: pedump.c:675

◆ EDIT_GetCompositionStr()

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

Definition at line 4492 of file edit.c.

4494{
4495 LONG buflen;
4496 LPWSTR lpCompStr;
4497 LPSTR lpCompStrAttr = NULL;
4498 DWORD dwBufLenAttr;
4499
4500 buflen = ImmGetCompositionStringW(hIMC, GCS_COMPSTR, NULL, 0);
4501
4502 if (buflen < 0)
4503 {
4504 return;
4505 }
4506
4507 lpCompStr = HeapAlloc(GetProcessHeap(),0,buflen + sizeof(WCHAR));
4508 if (!lpCompStr)
4509 {
4510 ERR("Unable to allocate IME CompositionString\n");
4511 return;
4512 }
4513
4514 if (buflen)
4515 ImmGetCompositionStringW(hIMC, GCS_COMPSTR, lpCompStr, buflen);
4516 lpCompStr[buflen/sizeof(WCHAR)] = 0;
4517
4518 if (CompFlag & GCS_COMPATTR)
4519 {
4520 /*
4521 * We do not use the attributes yet. it would tell us what characters
4522 * are in transition and which are converted or decided upon
4523 */
4524 dwBufLenAttr = ImmGetCompositionStringW(hIMC, GCS_COMPATTR, NULL, 0);
4525 if (dwBufLenAttr)
4526 {
4527 dwBufLenAttr ++;
4528 lpCompStrAttr = HeapAlloc(GetProcessHeap(),0,dwBufLenAttr+1);
4529 if (!lpCompStrAttr)
4530 {
4531 ERR("Unable to allocate IME Attribute String\n");
4532 HeapFree(GetProcessHeap(),0,lpCompStr);
4533 return;
4534 }
4535 ImmGetCompositionStringW(hIMC,GCS_COMPATTR, lpCompStrAttr,
4536 dwBufLenAttr);
4537 lpCompStrAttr[dwBufLenAttr] = 0;
4538 }
4539 }
4540
4541#ifndef __REACTOS__ /* We don't use internal composition string. Rely on the composition window */
4542 /* check for change in composition start */
4543 if (es->selection_end < es->composition_start)
4544 es->composition_start = es->selection_end;
4545
4546 /* replace existing selection string */
4547 es->selection_start = es->composition_start;
4548
4549 if (es->composition_len > 0)
4550 es->selection_end = es->composition_start + es->composition_len;
4551 else
4552 es->selection_end = es->selection_start;
4553
4554 EDIT_EM_ReplaceSel(es, FALSE, lpCompStr, TRUE, TRUE);
4555 es->composition_len = abs(es->composition_start - es->selection_end);
4556
4557 es->selection_start = es->composition_start;
4558 es->selection_end = es->selection_start + es->composition_len;
4559#endif
4560
4561 HeapFree(GetProcessHeap(),0,lpCompStrAttr);
4562 HeapFree(GetProcessHeap(),0,lpCompStr);
LONG WINAPI ImmGetCompositionStringW(HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)
Definition: compstr.c:899
unsigned long DWORD
Definition: ntddk_ex.h:95
#define GCS_COMPATTR
Definition: imm.h:228
#define GCS_COMPSTR
Definition: imm.h:227

◆ EDIT_GetLineRect()

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

Definition at line 1239 of file edit.c.

1241{
1243 INT line_index = 0;
1244 INT pt1, pt2, pt3;
1245
1246 if (es->style & ES_MULTILINE)
1247 {
1248 const LINEDEF *line_def = NULL;
1249 rc->top = es->format_rect.top + (line - es->y_offset) * es->line_height;
1250 if (line >= es->line_count)
1251 return;
1252
1253 line_def = es->first_line_def;
1254 if (line == -1) {
1255 INT index = es->selection_end - line_def->length;
1256 while ((index >= 0) && line_def->next) {
1257 line_index += line_def->length;
1258 line_def = line_def->next;
1259 index -= line_def->length;
1260 }
1261 } else {
1262 while (line > 0) {
1263 line_index += line_def->length;
1264 line_def = line_def->next;
1265 line--;
1266 }
1267 }
1268 ssa = line_def->ssa;
1269 }
1270 else
1271 {
1272 line_index = 0;
1273 rc->top = es->format_rect.top;
1274 ssa = es->ssa;
1275 }
1276
1277 rc->bottom = rc->top + es->line_height;
1278 pt1 = (scol == 0) ? es->format_rect.left : (short)LOWORD(EDIT_EM_PosFromChar(es, line_index + scol, TRUE));
1279 pt2 = (ecol == -1) ? es->format_rect.right : (short)LOWORD(EDIT_EM_PosFromChar(es, line_index + ecol, TRUE));
1280 if (ssa)
1281 {
1282 ScriptStringCPtoX(ssa, scol, FALSE, &pt3);
1283 pt3+=es->format_rect.left;
1284 }
1285 else pt3 = pt1;
1286 rc->right = max(max(pt1 , pt2),pt3);
1287 rc->left = min(min(pt1, pt2),pt3);

◆ EDIT_GetResultStr()

static void EDIT_GetResultStr ( HIMC  hIMC,
EDITSTATE es 
)
static

Definition at line 4564 of file edit.c.

4566{
4567 LONG buflen;
4568 LPWSTR lpResultStr;
4569
4570 buflen = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
4571 if (buflen <= 0)
4572 {
4573 return;
4574 }
4575
4576 lpResultStr = HeapAlloc(GetProcessHeap(),0, buflen+sizeof(WCHAR));
4577 if (!lpResultStr)
4578 {
4579 ERR("Unable to alloc buffer for IME string\n");
4580 return;
4581 }
4582
4583 ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, lpResultStr, buflen);
4584 lpResultStr[buflen/sizeof(WCHAR)] = 0;
4585
4586#ifndef __REACTOS__
4587 /* check for change in composition start */
4588 if (es->selection_end < es->composition_start)
4589 es->composition_start = es->selection_end;
4590
4591 es->selection_start = es->composition_start;
4592 es->selection_end = es->composition_start + es->composition_len;
4593 EDIT_EM_ReplaceSel(es, TRUE, lpResultStr, TRUE, TRUE);
4594 es->composition_start = es->selection_end;
4595 es->composition_len = 0;
4596#endif
4597
4598 HeapFree(GetProcessHeap(),0,lpResultStr);
#define GCS_RESULTSTR
Definition: imm.h:234

◆ EDIT_ImeComposition()

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

Definition at line 4600 of file edit.c.

4602{
4603 HIMC hIMC;
4604 int cursor;
4605
4606#ifdef __REACTOS__
4607 if (es->selection_start != es->selection_end)
4609#else
4610 if (es->composition_len == 0 && es->selection_start != es->selection_end)
4611 {
4613 es->composition_start = es->selection_end;
4614 }
4615#endif
4616
4617 hIMC = ImmGetContext(hwnd);
4618 if (!hIMC)
4619 return;
4620
4621 if (CompFlag & GCS_RESULTSTR)
4622 {
4623 EDIT_GetResultStr(hIMC, es);
4624 cursor = 0;
4625 }
4626 else
4627 {
4628 if (CompFlag & GCS_COMPSTR)
4629 EDIT_GetCompositionStr(hIMC, CompFlag, es);
4630#ifdef __REACTOS__
4631 cursor = 0;
4632#else
4634#endif
4635 }
4636 ImmReleaseContext(hwnd, hIMC);
4637 EDIT_SetCaretPos(es, es->selection_start + cursor, es->flags & EF_AFTER_WRAP);
DWORD HIMC
Definition: dimm.idl:75
static void EDIT_GetResultStr(HIMC hIMC, EDITSTATE *es)
Definition: edit.c:4343
static void EDIT_GetCompositionStr(HIMC hIMC, LPARAM CompFlag, EDITSTATE *es)
Definition: edit.c:4272
HIMC WINAPI ImmGetContext(HWND hWnd)
Definition: imm.c:1044
BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
Definition: imm.c:1085
const char cursor[]
Definition: icontest.c:13
#define GCS_CURSORPOS
Definition: imm.h:230
static const WCHAR empty_stringW[]
Definition: edit.c:173

◆ EDIT_InvalidateText()

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

Definition at line 1616 of file edit.c.

1618{
1619 if (end == start)
1620 return;
1621
1622 if (end == -1)
1624
1625 if (end < start) {
1626 INT tmp = start;
1627 start = end;
1628 end = tmp;
1629 }
1630
1631 if (es->style & ES_MULTILINE)
1633 else
static void EDIT_ML_InvalidateText(EDITSTATE *es, INT start, INT end)
Definition: edit.c:1392
static void EDIT_SL_InvalidateText(EDITSTATE *es, INT start, INT end)
Definition: edit.c:1374

◆ EDIT_InvalidateUniscribeData()

static void EDIT_InvalidateUniscribeData ( EDITSTATE es)
inlinestatic

Definition at line 391 of file edit.c.

393{
394 LINEDEF *line_def = es->first_line_def;
395 while (line_def)
396 {
398 line_def = line_def->next;
399 }
400 if (es->ssa)
401 {
402 ScriptStringFree(&es->ssa);
403 es->ssa = NULL;
404 }
HRESULT WINAPI ScriptStringFree(SCRIPT_STRING_ANALYSIS *pssa)
Definition: usp10.c:2556

◆ EDIT_InvalidateUniscribeData_linedef()

static void EDIT_InvalidateUniscribeData_linedef ( LINEDEF line_def)
inlinestatic

Definition at line 382 of file edit.c.

384{
385 if (line_def->ssa)
386 {
387 ScriptStringFree(&line_def->ssa);
388 line_def->ssa = NULL;
389 }

◆ EDIT_IsInsideDialog()

static BOOL EDIT_IsInsideDialog ( EDITSTATE es)
inlinestatic

Definition at line 3194 of file edit.c.

3196{
3197 return (es->flags & EF_DIALOGMODE);
#define EF_DIALOGMODE
Definition: edit.c:77

◆ EDIT_LockBuffer()

static void EDIT_LockBuffer ( EDITSTATE es)
static

Definition at line 1303 of file edit.c.

1305{
1306 if (!es->text) {
1307
1308#ifdef __REACTOS__
1309/* FIXME: What is this ? */
1310 CHAR *textA = NULL; // ReactOS Hacked! r45670
1311 //UINT countA = 0;
1312
1313 if(es->hloc32W)
1314 {
1315 if(es->hloc32A)
1316 {
1317 TRACE("Synchronizing with 32-bit ANSI buffer\n");
1318 textA = LocalLock(es->hloc32A);
1319 //countA = strlen(textA) + 1;
1320 }
1321 }
1322 else {
1323 ERR("no buffer ... please report\n");
1324 return;
1325 }
1326
1327 if (textA)
1328 {
1329#else
1330 if(!es->hloc32W) return;
1331
1332 if(es->hloc32A)
1333 {
1334 CHAR *textA = LocalLock(es->hloc32A);
1335#endif
1336 HLOCAL hloc32W_new;
1337 UINT countW_new = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
1338 if(countW_new > es->buffer_size + 1)
1339 {
1340 UINT alloc_size = ROUND_TO_GROW(countW_new * sizeof(WCHAR));
1341 TRACE("Resizing 32-bit UNICODE buffer from %d+1 to %d WCHARs\n", es->buffer_size, countW_new);
1342 hloc32W_new = LocalReAlloc(es->hloc32W, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT);
1343 if(hloc32W_new)
1344 {
1345 es->hloc32W = hloc32W_new;
1346 es->buffer_size = LocalSize(hloc32W_new)/sizeof(WCHAR) - 1;
1347 TRACE("Real new size %d+1 WCHARs\n", es->buffer_size);
1348 }
1349 else
1350 WARN("FAILED! Will synchronize partially\n");
1351 }
1352 es->text = LocalLock(es->hloc32W);
1353 MultiByteToWideChar(CP_ACP, 0, textA, -1, es->text, es->buffer_size + 1);
1354 LocalUnlock(es->hloc32A);
1355 }
1356 else es->text = LocalLock(es->hloc32W);
1357 }
1358 es->lock_count++;
HLOCAL NTAPI LocalReAlloc(HLOCAL hMem, SIZE_T dwBytes, UINT uFlags)
Definition: heapmem.c:1625

◆ EDIT_MakeFit()

static BOOL EDIT_MakeFit ( EDITSTATE es,
UINT  size 
)
static

Definition at line 1433 of file edit.c.

1435{
1436 HLOCAL hNew32W;
1437
1438 if (size <= es->buffer_size)
1439 return TRUE;
1440
1441 TRACE("trying to ReAlloc to %d+1 characters\n", size);
1442
1443 /* Force edit to unlock its buffer. es->text now NULL */
1445
1446 if (es->hloc32W) {
1447 UINT alloc_size = ROUND_TO_GROW((size + 1) * sizeof(WCHAR));
1448 if ((hNew32W = LocalReAlloc(es->hloc32W, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT))) {
1449 TRACE("Old 32 bit handle %p, new handle %p\n", es->hloc32W, hNew32W);
1450 es->hloc32W = hNew32W;
1451 es->buffer_size = LocalSize(hNew32W)/sizeof(WCHAR) - 1;
1452 }
1453 }
1454
1456
1457 if (es->buffer_size < size) {
1458 WARN("FAILED ! We now have %d+1\n", es->buffer_size);
1460 return FALSE;
1461 } else {
1462 TRACE("We now have %d+1\n", es->buffer_size);
1463 return TRUE;
1464 }
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:888
#define EN_ERRSPACE
Definition: winuser.h:2023

◆ EDIT_MakeUndoFit()

static BOOL EDIT_MakeUndoFit ( EDITSTATE es,
UINT  size 
)
static

Definition at line 1474 of file edit.c.

1476{
1477 UINT alloc_size;
1478
1479 if (size <= es->undo_buffer_size)
1480 return TRUE;
1481
1482 TRACE("trying to ReAlloc to %d+1\n", size);
1483
1484 alloc_size = ROUND_TO_GROW((size + 1) * sizeof(WCHAR));
1485 if ((es->undo_text = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, es->undo_text, alloc_size))) {
1486 es->undo_buffer_size = alloc_size/sizeof(WCHAR) - 1;
1487 return TRUE;
1488 }
1489 else
1490 {
1491 WARN("FAILED ! We now have %d+1\n", es->undo_buffer_size);
1492 return FALSE;
1493 }
#define HeapReAlloc
Definition: compat.h:734

◆ EDIT_ML_InvalidateText()

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

Definition at line 1551 of file edit.c.

1553{
1557 INT sc;
1558 INT ec;
1559 RECT rc1;
1560 RECT rcWnd;
1561 RECT rcLine;
1562 RECT rcUpdate;
1563 INT l;
1564
1565 if ((el < es->y_offset) || (sl > es->y_offset + vlc))
1566 return;
1567
1568 sc = start - EDIT_EM_LineIndex(es, sl);
1569 ec = end - EDIT_EM_LineIndex(es, el);
1570 if (sl < es->y_offset) {
1571 sl = es->y_offset;
1572 sc = 0;
1573 }
1574 if (el > es->y_offset + vlc) {
1575 el = es->y_offset + vlc;
1577 }
1578 GetClientRect(es->hwndSelf, &rc1);
1579 IntersectRect(&rcWnd, &rc1, &es->format_rect);
1580 if (sl == el) {
1581 EDIT_GetLineRect(es, sl, sc, ec, &rcLine);
1582 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1583 EDIT_UpdateText(es, &rcUpdate, TRUE);
1584 } else {
1585 EDIT_GetLineRect(es, sl, sc,
1587 EDIT_EM_LineIndex(es, sl)),
1588 &rcLine);
1589 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1590 EDIT_UpdateText(es, &rcUpdate, TRUE);
1591 for (l = sl + 1 ; l < el ; l++) {
1592 EDIT_GetLineRect(es, l, 0,
1595 &rcLine);
1596 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1597 EDIT_UpdateText(es, &rcUpdate, TRUE);
1598 }
1599 EDIT_GetLineRect(es, el, 0, ec, &rcLine);
1600 if (IntersectRect(&rcUpdate, &rcWnd, &rcLine))
1601 EDIT_UpdateText(es, &rcUpdate, TRUE);
1602 }
static void EDIT_GetLineRect(EDITSTATE *es, INT line, INT scol, INT ecol, LPRECT rc)
Definition: edit.c:1145

◆ EDIT_MoveBackward()

static void EDIT_MoveBackward ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2002 of file edit.c.

2004{
2005 INT e = es->selection_end;
2006
2007 if (e) {
2008 e--;
2009 if ((es->style & ES_MULTILINE) && e &&
2010 (es->text[e - 1] == '\r') && (es->text[e] == '\n')) {
2011 e--;
2012 if (e && (es->text[e - 1] == '\r'))
2013 e--;
2014 }
2015 }
2016 EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, FALSE);

◆ EDIT_MoveDown_ML()

static void EDIT_MoveDown_ML ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2029 of file edit.c.

2031{
2032 INT s = es->selection_start;
2033 INT e = es->selection_end;
2034 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
2035 LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
2036 INT x = (short)LOWORD(pos);
2037 INT y = (short)HIWORD(pos);
2038
2039 e = EDIT_CharFromPos(es, x, y + es->line_height, &after_wrap);
2040 if (!extend)
2041 s = e;
2042 EDIT_EM_SetSel(es, s, e, after_wrap);
#define HIWORD(l)
Definition: typedefs.h:247

◆ EDIT_MoveEnd()

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

Definition at line 2051 of file edit.c.

2053{
2054 BOOL after_wrap = FALSE;
2055 INT e;
2056
2057 /* Pass a high value in x to make sure of receiving the end of the line */
2058 if (!ctrl && (es->style & ES_MULTILINE))
2059 e = EDIT_CharFromPos(es, 0x3fffffff,
2060 HIWORD(EDIT_EM_PosFromChar(es, es->selection_end, es->flags & EF_AFTER_WRAP)), &after_wrap);
2061 else
2062 e = get_text_length(es);
2063 EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, after_wrap);
#define ctrl
Definition: input.c:1756

◆ EDIT_MoveForward()

static void EDIT_MoveForward ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2072 of file edit.c.

2074{
2075 INT e = es->selection_end;
2076
2077 if (es->text[e]) {
2078 e++;
2079 if ((es->style & ES_MULTILINE) && (es->text[e - 1] == '\r')) {
2080 if (es->text[e] == '\n')
2081 e++;
2082 else if ((es->text[e] == '\r') && (es->text[e + 1] == '\n'))
2083 e += 2;
2084 }
2085 }
2086 EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, FALSE);

◆ EDIT_MoveHome()

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

Definition at line 2097 of file edit.c.

2099{
2100 INT e;
2101
2102 /* Pass the x_offset in x to make sure of receiving the first position of the line */
2103 if (!ctrl && (es->style & ES_MULTILINE))
2104 e = EDIT_CharFromPos(es, -es->x_offset,
2105 HIWORD(EDIT_EM_PosFromChar(es, es->selection_end, es->flags & EF_AFTER_WRAP)), NULL);
2106 else
2107 e = 0;
2108 EDIT_EM_SetSel(es, extend ? es->selection_start : e, e, FALSE);

◆ EDIT_MovePageDown_ML()

static void EDIT_MovePageDown_ML ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2121 of file edit.c.

2123{
2124 INT s = es->selection_start;
2125 INT e = es->selection_end;
2126 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
2127 LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
2128 INT x = (short)LOWORD(pos);
2129 INT y = (short)HIWORD(pos);
2130
2132 y + (es->format_rect.bottom - es->format_rect.top),
2133 &after_wrap);
2134 if (!extend)
2135 s = e;
2136 EDIT_EM_SetSel(es, s, e, after_wrap);

◆ EDIT_MovePageUp_ML()

static void EDIT_MovePageUp_ML ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2149 of file edit.c.

2151{
2152 INT s = es->selection_start;
2153 INT e = es->selection_end;
2154 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
2155 LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
2156 INT x = (short)LOWORD(pos);
2157 INT y = (short)HIWORD(pos);
2158
2160 y - (es->format_rect.bottom - es->format_rect.top),
2161 &after_wrap);
2162 if (!extend)
2163 s = e;
2164 EDIT_EM_SetSel(es, s, e, after_wrap);

◆ EDIT_MoveUp_ML()

static void EDIT_MoveUp_ML ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2177 of file edit.c.

2179{
2180 INT s = es->selection_start;
2181 INT e = es->selection_end;
2182 BOOL after_wrap = (es->flags & EF_AFTER_WRAP);
2183 LRESULT pos = EDIT_EM_PosFromChar(es, e, after_wrap);
2184 INT x = (short)LOWORD(pos);
2185 INT y = (short)HIWORD(pos);
2186
2187 e = EDIT_CharFromPos(es, x, y - es->line_height, &after_wrap);
2188 if (!extend)
2189 s = e;
2190 EDIT_EM_SetSel(es, s, e, after_wrap);

◆ EDIT_MoveWordBackward()

static void EDIT_MoveWordBackward ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2199 of file edit.c.

2201{
2202 INT s = es->selection_start;
2203 INT e = es->selection_end;
2204 INT l;
2205 INT ll;
2206 INT li;
2207
2211 if (e - li == 0) {
2212 if (l) {
2213 li = EDIT_EM_LineIndex(es, l - 1);
2214 e = li + EDIT_EM_LineLength(es, li);
2215 }
2216 } else {
2218 }
2219 if (!extend)
2220 s = e;
w ll
Definition: byte_order.h:167

◆ EDIT_MoveWordForward()

static void EDIT_MoveWordForward ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2230 of file edit.c.

2232{
2233 INT s = es->selection_start;
2234 INT e = es->selection_end;
2235 INT l;
2236 INT ll;
2237 INT li;
2238
2242 if (e - li == ll) {
2243 if ((es->style & ES_MULTILINE) && (l != es->line_count - 1))
2244 e = EDIT_EM_LineIndex(es, l + 1);
2245 } else {
2247 li, e - li + 1, ll, WB_RIGHT);
2248 }
2249 if (!extend)
2250 s = e;
#define WB_RIGHT
Definition: winuser.h:551

◆ EDIT_NotifyCtlColor()

static HBRUSH EDIT_NotifyCtlColor ( EDITSTATE es,
HDC  hdc 
)
static

Definition at line 242 of file edit.c.

244{
245 HBRUSH hbrush;
246 UINT msg;
247
248 if ( get_app_version() >= 0x40000 && (!es->bEnableState || (es->style & ES_READONLY)))
250 else
252
253 /* why do we notify to es->hwndParent, and we send this one to GetParent()? */
254#ifdef __REACTOS__
255 /* ReactOS r54259 */
256 hbrush = GetControlBrush(es->hwndSelf, hdc, msg);
257#else
258 hbrush = (HBRUSH)SendMessageW(GetParent(es->hwndSelf), msg, (WPARAM)hdc, (LPARAM)es->hwndSelf);
259 if (!hbrush)
260 hbrush = (HBRUSH)DefWindowProcW(GetParent(es->hwndSelf), msg, (WPARAM)hdc, (LPARAM)es->hwndSelf);
261#endif
262 return hbrush;
static HBRUSH hbrush
HDC hdc
Definition: main.c:9
HBRUSH FASTCALL GetControlBrush(PWND pwnd, HDC hdc, UINT ctlType)
Definition: misc.c:180
static DWORD get_app_version(void)
Definition: edit.c:223
LONG_PTR LPARAM
Definition: windef.h:208
UINT_PTR WPARAM
Definition: windef.h:207
#define WM_CTLCOLORSTATIC
Definition: winuser.h:1772
#define WM_CTLCOLOREDIT
Definition: winuser.h:1767

◆ EDIT_PaintLine()

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

Definition at line 2334 of file edit.c.

2336{
2337 INT s = 0;
2338 INT e = 0;
2339 INT li = 0;
2340 INT ll = 0;
2341 INT x;
2342 INT y;
2343 LRESULT pos;
2345
2346 if (es->style & ES_MULTILINE) {
2348
2349 if ((line < es->y_offset) || (line > es->y_offset + vlc) || (line >= es->line_count))
2350 return;
2351 } else if (line)
2352 return;
2353
2354 TRACE("line=%d\n", line);
2355
2358 x = (short)LOWORD(pos);
2359 y = (short)HIWORD(pos);
2360
2361 if (es->style & ES_MULTILINE)
2362 {
2363 int line_idx = line;
2364 x = -es->x_offset;
2365 if (es->style & ES_RIGHT || es->style & ES_CENTER)
2366 {
2367 LINEDEF *line_def = es->first_line_def;
2368 int w, lw;
2369
2370 while (line_def && line_idx)
2371 {
2372 line_def = line_def->next;
2373 line_idx--;
2374 }
2375 w = es->format_rect.right - es->format_rect.left;
2376 lw = line_def->width;
2377
2378 if (es->style & ES_RIGHT)
2379 x = w - (lw - x);
2380 else if (es->style & ES_CENTER)
2381 x += (w - lw) / 2;
2382 }
2383 x += es->format_rect.left;
2384 }
2385
2386 if (rev)
2387 {
2390 s = min(es->selection_start, es->selection_end);
2391 e = max(es->selection_start, es->selection_end);
2392 s = min(li + ll, max(li, s));
2393 e = min(li + ll, max(li, e));
2394 }
2395
2396 if (ssa)
2397 ScriptStringOut(ssa, x, y, 0, &es->format_rect, s - li, e - li, FALSE);
2398 else if (rev && (s != e) &&
2399 ((es->flags & EF_FOCUSED) || (es->style & ES_NOHIDESEL))) {
2400 x += EDIT_PaintText(es, dc, x, y, line, 0, s - li, FALSE);
2401 x += EDIT_PaintText(es, dc, x, y, line, s - li, e - s, TRUE);
2402 x += EDIT_PaintText(es, dc, x, y, line, e - li, li + ll - e, FALSE);
2403 } else
2404 x += EDIT_PaintText(es, dc, x, y, line, 0, ll, FALSE);
int rev
Definition: sort.c:17
static INT EDIT_PaintText(EDITSTATE *es, HDC dc, INT x, INT y, INT line, INT col, INT count, BOOL rev)
Definition: edit.c:2106
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
#define ES_NOHIDESEL
Definition: pedump.c:673

◆ 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 2260 of file edit.c.

2262{
2263 COLORREF BkColor;
2264 COLORREF TextColor;
2265 LOGFONTW underline_font;
2266 HFONT hUnderline = 0;
2267 HFONT old_font = 0;
2268 INT ret;
2269 INT li;
2270 INT BkMode;
2271 SIZE size;
2272
2273 if (!count)
2274 return 0;
2275 BkMode = GetBkMode(dc);
2276 BkColor = GetBkColor(dc);
2277 TextColor = GetTextColor(dc);
2278 if (rev) {
2279#ifdef __REACTOS__
2280 if (TRUE)
2281#else
2282 if (es->composition_len == 0)
2283#endif
2284 {
2287 SetBkMode( dc, OPAQUE);
2288 }
2289 else
2290 {
2292 GetObjectW(current,sizeof(LOGFONTW),&underline_font);
2293 underline_font.lfUnderline = TRUE;
2294 hUnderline = CreateFontIndirectW(&underline_font);
2295 old_font = SelectObject(dc,hUnderline);
2296 }
2297 }
2299 if (es->style & ES_MULTILINE) {
2300 ret = (INT)LOWORD(TabbedTextOutW(dc, x, y, es->text + li + col, count,
2301 es->tabs_count, es->tabs, es->format_rect.left - es->x_offset));
2302 } else {
2303 TextOutW(dc, x, y, es->text + li + col, count);
2304 GetTextExtentPoint32W(dc, es->text + li + col, count, &size);
2305 ret = size.cx;
2306 }
2307 if (rev) {
2308#ifdef __REACTOS__
2309 if (TRUE)
2310#else
2311 if (es->composition_len == 0)
2312#endif
2313 {
2314 SetBkColor(dc, BkColor);
2315 SetTextColor(dc, TextColor);
2316 SetBkMode( dc, BkMode);
2317 }
2318 else
2319 {
2320 if (old_font)
2321 SelectObject(dc,old_font);
2322 if (hUnderline)
2323 DeleteObject(hUnderline);
2324 }
2325 }
2326 return ret;
struct task_struct * current
Definition: linux.c:32
#define OBJ_FONT
Definition: objidl.idl:1414
#define INT
Definition: polytest.cpp:20
BYTE lfUnderline
Definition: dimm.idl:65
DWORD COLORREF
Definition: windef.h:300
int WINAPI GetBkMode(_In_ HDC)
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
COLORREF WINAPI SetBkColor(_In_ HDC, _In_ COLORREF)
Definition: dc.c:999
COLORREF WINAPI GetTextColor(_In_ HDC)
Definition: text.c:861
HGDIOBJ WINAPI GetCurrentObject(_In_ HDC, _In_ UINT)
Definition: dc.c:428
COLORREF WINAPI GetBkColor(_In_ HDC)
Definition: dc.c:978
#define OPAQUE
Definition: wingdi.h:949
BOOL WINAPI TextOutW(_In_ HDC hdc, _In_ int x, _In_ int y, _In_reads_(c) LPCWSTR lpString, _In_ int c)
HFONT WINAPI CreateFontIndirectW(_In_ const LOGFONTW *)
int WINAPI SetBkMode(_In_ HDC, _In_ int)
Definition: dc.c:1056
COLORREF WINAPI SetTextColor(_In_ HDC, _In_ COLORREF)
Definition: text.c:918
BOOL WINAPI GetTextExtentPoint32W(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpString, _In_ int c, _Out_ LPSIZE psizl)
DWORD WINAPI GetSysColor(_In_ int)
#define COLOR_HIGHLIGHT
Definition: winuser.h:926
#define COLOR_HIGHLIGHTTEXT
Definition: winuser.h:927
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)

◆ EDIT_SetCaretPos()

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

Definition at line 1902 of file edit.c.

1905{
1906 LRESULT res = EDIT_EM_PosFromChar(es, pos, after_wrap);
1907#ifdef __REACTOS__
1908 HKL hKL = GetKeyboardLayout(0);
1909 POINT pt = { (short)LOWORD(res), (short)HIWORD(res) };
1910
1911 /* Don't set caret if not focused */
1912 if ((es->flags & EF_FOCUSED) == 0)
1913 return;
1914
1915 SetCaretPos(pt.x, pt.y);
1916
1917 if (!ImmIsIME(hKL))
1918 return;
1919
1920 EDIT_ImmSetCompositionWindow(es, pt);
1921#else
1922 TRACE("%d - %dx%d\n", pos, (short)LOWORD(res), (short)HIWORD(res));
1923 SetCaretPos((short)LOWORD(res), (short)HIWORD(res));
1924#endif
BOOL WINAPI ImmIsIME(HKL hKL)
Definition: ime.c:880
GLuint res
Definition: glext.h:9613
UINT_PTR HKL
Definition: msctf.idl:143
HKL WINAPI GetKeyboardLayout(_In_ DWORD)
BOOL WINAPI SetCaretPos(_In_ int, _In_ int)

◆ EDIT_SetRectNP()

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

Definition at line 2466 of file edit.c.

2468{
2470 INT bw, bh;
2472
2473 CopyRect(&es->format_rect, rc);
2474
2475 if (ExStyle & WS_EX_CLIENTEDGE) {
2476 es->format_rect.left++;
2477 es->format_rect.right--;
2478
2479 if (es->format_rect.bottom - es->format_rect.top
2480 >= es->line_height + 2)
2481 {
2482 es->format_rect.top++;
2483 es->format_rect.bottom--;
2484 }
2485 }
2486 else if (es->style & WS_BORDER) {
2488 bh = GetSystemMetrics(SM_CYBORDER) + 1;
2489 es->format_rect.left += bw;
2490 es->format_rect.right -= bw;
2491 if (es->format_rect.bottom - es->format_rect.top
2492 >= es->line_height + 2 * bh)
2493 {
2494 es->format_rect.top += bh;
2495 es->format_rect.bottom -= bh;
2496 }
2497 }
2498
2499 es->format_rect.left += es->left_margin;
2500 es->format_rect.right -= es->right_margin;
static int bw
Definition: maze.c:120
const DWORD ExStyle
Definition: appswitch.c:72
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
#define WS_BORDER
Definition: pedump.c:625
BOOL WINAPI CopyRect(_Out_ LPRECT, _In_ LPCRECT)
#define GetWindowLongPtrW
Definition: winuser.h:4829
#define SM_CYBORDER
Definition: winuser.h:965
#define SM_CXBORDER
Definition: winuser.h:964
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
int WINAPI GetSystemMetrics(_In_ int)
#define GWL_EXSTYLE
Definition: winuser.h:851

◆ EDIT_SL_InvalidateText()

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

Definition at line 1533 of file edit.c.

1535{
1536 RECT line_rect;
1537 RECT rc;
1538
1539 EDIT_GetLineRect(es, 0, start, end, &line_rect);
1540 if (IntersectRect(&rc, &line_rect, &es->format_rect))
1541 EDIT_UpdateText(es, &rc, TRUE);

◆ EDIT_UnlockBuffer()

static void EDIT_UnlockBuffer ( EDITSTATE es,
BOOL  force 
)
static

Definition at line 1366 of file edit.c.

1368{
1369 /* Edit window might be already destroyed */
1370 if(!IsWindow(es->hwndSelf))
1371 {
1372 WARN("edit hwnd %p already destroyed\n", es->hwndSelf);
1373 return;
1374 }
1375
1376 if (!es->lock_count) {
1377 ERR("lock_count == 0 ... please report\n");
1378 return;
1379 }
1380 if (!es->text) {
1381 ERR("es->text == 0 ... please report\n");
1382 return;
1383 }
1384
1385 if (force || (es->lock_count == 1)) {
1386 if (es->hloc32W) {
1387 UINT countA = 0;
1388 UINT countW = get_text_length(es) + 1;
1389
1390 if(es->hloc32A)
1391 {
1392 UINT countA_new = WideCharToMultiByte(CP_ACP, 0, es->text, countW, NULL, 0, NULL, NULL);
1393 TRACE("Synchronizing with 32-bit ANSI buffer\n");
1394 TRACE("%d WCHARs translated to %d bytes\n", countW, countA_new);
1395 countA = LocalSize(es->hloc32A);
1396 if(countA_new > countA)
1397 {
1398 HLOCAL hloc32A_new;
1399 UINT alloc_size = ROUND_TO_GROW(countA_new);
1400 TRACE("Resizing 32-bit ANSI buffer from %d to %d bytes\n", countA, alloc_size);
1401 hloc32A_new = LocalReAlloc(es->hloc32A, alloc_size, LMEM_MOVEABLE | LMEM_ZEROINIT);
1402 if(hloc32A_new)
1403 {
1404 es->hloc32A = hloc32A_new;
1405 countA = LocalSize(hloc32A_new);
1406 TRACE("Real new size %d bytes\n", countA);
1407 }
1408 else
1409 WARN("FAILED! Will synchronize partially\n");
1410 }
1411 WideCharToMultiByte(CP_ACP, 0, es->text, countW,
1412 LocalLock(es->hloc32A), countA, NULL, NULL);
1413 LocalUnlock(es->hloc32A);
1414 }
1415
1416 LocalUnlock(es->hloc32W);
1417 es->text = NULL;
1418 }
1419 else {
1420 ERR("no buffer ... please report\n");
1421 return;
1422 }
1423 }
1424 es->lock_count--;
BOOL WINAPI IsWindow(_In_opt_ HWND)

◆ EDIT_UpdateScrollInfo()

static void EDIT_UpdateScrollInfo ( EDITSTATE es)
static

Definition at line 1712 of file edit.c.

1714{
1715 if ((es->style & WS_VSCROLL) && !(es->flags & EF_VSCROLL_TRACK))
1716 {
1717 SCROLLINFO si;
1718 si.cbSize = sizeof(SCROLLINFO);
1720 si.nMin = 0;
1721 si.nMax = es->line_count - 1;
1722 si.nPage = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
1723 si.nPos = es->y_offset;
1724 TRACE("SB_VERT, nMin=%d, nMax=%d, nPage=%d, nPos=%d\n",
1725 si.nMin, si.nMax, si.nPage, si.nPos);
1726 SetScrollInfo(es->hwndSelf, SB_VERT, &si, TRUE);
1727 }
1728
1729 if ((es->style & WS_HSCROLL) && !(es->flags & EF_HSCROLL_TRACK))
1730 {
1731 SCROLLINFO si;
1732 si.cbSize = sizeof(SCROLLINFO);
1734 si.nMin = 0;
1735 si.nMax = es->text_width - 1;
1736 si.nPage = es->format_rect.right - es->format_rect.left;
1737 si.nPos = es->x_offset;
1738 TRACE("SB_HORZ, nMin=%d, nMax=%d, nPage=%d, nPos=%d\n",
1739 si.nMin, si.nMax, si.nPage, si.nPos);
1740 SetScrollInfo(es->hwndSelf, SB_HORZ, &si, TRUE);
1741 }
#define WS_VSCROLL
Definition: pedump.c:627
#define WS_HSCROLL
Definition: pedump.c:628
struct tagSCROLLINFO SCROLLINFO
#define SIF_RANGE
Definition: winuser.h:1235
#define SB_VERT
Definition: winuser.h:553
#define SIF_PAGE
Definition: winuser.h:1233
#define SIF_DISABLENOSCROLL
Definition: winuser.h:1236
#define SIF_POS
Definition: winuser.h:1234
int WINAPI SetScrollInfo(_In_ HWND, _In_ int, _In_ LPCSCROLLINFO, _In_ BOOL)
#define SB_HORZ
Definition: winuser.h:552

◆ EDIT_UpdateText()

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

Definition at line 1516 of file edit.c.

1518{
1519 if (es->flags & EF_UPDATE) {
1520 es->flags &= ~EF_UPDATE;
1521 if (!notify_parent(es, EN_UPDATE)) return;
1522 }
1523 InvalidateRect(es->hwndSelf, rc, bErase);
#define EN_UPDATE
Definition: winuser.h:2028
BOOL WINAPI InvalidateRect(_In_opt_ HWND, _In_opt_ LPCRECT, _In_ BOOL)

◆ EDIT_UpdateTextRegion()

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

Definition at line 1501 of file edit.c.

1503{
1504 if (es->flags & EF_UPDATE) {
1505 es->flags &= ~EF_UPDATE;
1506 if (!notify_parent(es, EN_UPDATE)) return;
1507 }
1508 InvalidateRgn(es->hwndSelf, hrgn, bErase);
BOOL WINAPI InvalidateRgn(_In_ HWND, _In_opt_ HRGN, _In_ BOOL)

◆ EDIT_UpdateUniscribeData()

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

Definition at line 453 of file edit.c.

455{
456 LINEDEF *line_def;
457
458 if (!(es->style & ES_MULTILINE))
459 {
460 if (!es->ssa)
461 {
463 HFONT old_font = NULL;
464 HDC udc = dc;
465
466 if (!udc)
467 udc = GetDC(es->hwndSelf);
468 if (es->font)
469 old_font = SelectObject(udc, es->font);
470
471 if (es->style & ES_PASSWORD)
472#ifdef __REACTOS__
473 /* ReactOS r57677 */
474 ScriptStringAnalyse(udc, &es->password_char, length, (3*length/2+16), -1, SSA_LINK|SSA_FALLBACK|SSA_GLYPHS|SSA_PASSWORD, -1, NULL, NULL, NULL, NULL, NULL, &es->ssa);
475#else
476 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);
477#endif
478 else
479#ifdef __REACTOS__
480 /* ReactOS r57677 */
481 ScriptStringAnalyse(udc, es->text, length, (3*length/2+16), -1, SSA_LINK|SSA_FALLBACK|SSA_GLYPHS, -1, NULL, NULL, NULL, NULL, NULL, &es->ssa);
482#else
483 ScriptStringAnalyse(udc, es->text, length, (1.5*length+16), -1, SSA_LINK|SSA_FALLBACK|SSA_GLYPHS, -1, NULL, NULL, NULL, NULL, NULL, &es->ssa);
484#endif
485
486 if (es->font)
487 SelectObject(udc, old_font);
488 if (udc != dc)
489 ReleaseDC(es->hwndSelf, udc);
490 }
491 return es->ssa;
492 }
493 else
494 {
495 line_def = es->first_line_def;
496 while (line_def && line)
497 {
498 line_def = line_def->next;
499 line--;
500 }
501
502 return EDIT_UpdateUniscribeData_linedef(es,dc,line_def);
503 }
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
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
#define SSA_FALLBACK
Definition: usp10.h:38
#define SSA_LINK
Definition: usp10.h:45
#define SSA_PASSWORD
Definition: usp10.h:33
#define SSA_GLYPHS
Definition: usp10.h:40

◆ EDIT_UpdateUniscribeData_linedef()

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

Definition at line 406 of file edit.c.

408{
409 if (!line_def)
410 return NULL;
411
412 if (line_def->net_length && !line_def->ssa)
413 {
414 int index = line_def->index;
415 HFONT old_font = NULL;
416 HDC udc = dc;
417 SCRIPT_TABDEF tabdef;
418 HRESULT hr;
419
420 if (!udc)
421 udc = GetDC(es->hwndSelf);
422 if (es->font)
423 old_font = SelectObject(udc, es->font);
424
425 tabdef.cTabStops = es->tabs_count;
426 tabdef.iScale = 0;
427 tabdef.pTabStops = es->tabs;
428 tabdef.iTabOrigin = 0;
429
430 hr = ScriptStringAnalyse(udc, &es->text[index], line_def->net_length,
431#ifdef __REACTOS__
432 /* ReactOS r57679 */
433 (3*line_def->net_length/2+16), -1,
434#else
435 (1.5*line_def->net_length+16), -1,
436#endif
438 NULL, NULL, NULL, &tabdef, NULL, &line_def->ssa);
439 if (FAILED(hr))
440 {
441 WARN("ScriptStringAnalyse failed (%x)\n",hr);
442 line_def->ssa = NULL;
443 }
444
445 if (es->font)
446 SelectObject(udc, old_font);
447 if (udc != dc)
448 ReleaseDC(es->hwndSelf, udc);
449 }
450
451 return line_def->ssa;
#define FAILED(hr)
Definition: intsafe.h:51
HRESULT hr
Definition: shlfolder.c:183
int * pTabStops
Definition: usp10.h:173
else
Definition: tritemp.h:161
#define SSA_TAB
Definition: usp10.h:34

◆ EDIT_WM_Char()

static LRESULT EDIT_WM_Char ( EDITSTATE es,
WCHAR  c 
)
static

Definition at line 3289 of file edit.c.

3291{
3292 BOOL control;
3293
3294#ifdef __REACTOS__
3295 if (es->bCaptureState)
3296 return 0;
3297#endif
3298
3299 control = GetKeyState(VK_CONTROL) & 0x8000;
3300
3301 switch (c) {
3302 case '\r':
3303 /* If it's not a multiline edit box, it would be ignored below.
3304 * For multiline edit without ES_WANTRETURN, we have to make a
3305 * special case.
3306 */
3307 if ((es->style & ES_MULTILINE) && !(es->style & ES_WANTRETURN))
3309 break;
3310 case '\n':
3311 if (es->style & ES_MULTILINE) {
3312 if (es->style & ES_READONLY) {
3315 } else {
3316 static const WCHAR cr_lfW[] = {'\r','\n',0};
3317 EDIT_EM_ReplaceSel(es, TRUE, cr_lfW, TRUE, TRUE);
3318 }
3319 }
3320 break;
3321 case '\t':
3322 if ((es->style & ES_MULTILINE) && !(es->style & ES_READONLY))
3323 {
3324 static const WCHAR tabW[] = {'\t',0};
3326 break;
3328 }
3329 break;
3330 case VK_BACK:
3331 if (!(es->style & ES_READONLY) && !control) {
3332 if (es->selection_start != es->selection_end)
3334 else {
3335 /* delete character left of caret */
3336 EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
3339 }
3340 }
3341 break;
3342 case 0x03: /* ^C */
3343 if (!(es->style & ES_PASSWORD))
3344 SendMessageW(es->hwndSelf, WM_COPY, 0, 0);
3345 break;
3346 case 0x16: /* ^V */
3347 if (!(es->style & ES_READONLY))
3348 SendMessageW(es->hwndSelf, WM_PASTE, 0, 0);
3349 break;
3350 case 0x18: /* ^X */
3351 if (!((es->style & ES_READONLY) || (es->style & ES_PASSWORD)))
3352 SendMessageW(es->hwndSelf, WM_CUT, 0, 0);
3353 break;
3354 case 0x1A: /* ^Z */
3355 if (!(es->style & ES_READONLY))
3356 SendMessageW(es->hwndSelf, WM_UNDO, 0, 0);
3357 break;
3358
3359 default:
3360 /*If Edit control style is ES_NUMBER allow users to key in only numeric values*/
3361 if( (es->style & ES_NUMBER) && !( c >= '0' && c <= '9') )
3362 break;
3363
3364 if (!(es->style & ES_READONLY) && (c >= ' ') && (c != 127)) {
3365 WCHAR str[2];
3366 str[0] = c;
3367 str[1] = '\0';
3369 }
3370 break;
3371 }
3372 return 1;
static BOOL EDIT_IsInsideDialog(EDITSTATE *es)
Definition: edit.c:2952
static void EDIT_MoveBackward(EDITSTATE *es, BOOL extend)
Definition: edit.c:1848
static void EDIT_MoveHome(EDITSTATE *es, BOOL extend, BOOL ctrl)
Definition: edit.c:1943
static void EDIT_WM_Clear(EDITSTATE *es)
Definition: edit.c:3028
static void EDIT_MoveDown_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:1875
#define ES_WANTRETURN
Definition: pedump.c:676
const WCHAR * str
#define VK_CONTROL
Definition: winuser.h:2203
#define VK_BACK
Definition: winuser.h:2198
#define ES_NUMBER
Definition: winuser.h:301
SHORT WINAPI GetKeyState(_In_ int)

◆ EDIT_WM_Clear()

static void EDIT_WM_Clear ( EDITSTATE es)
inlinestatic

Definition at line 3262 of file edit.c.

3264{
3265 /* Protect read-only edit control from modification */
3266 if(es->style & ES_READONLY)
3267 return;
3268

◆ EDIT_WM_ContextMenu()

static void EDIT_WM_ContextMenu ( EDITSTATE es,
INT  x,
INT  y 
)
static

Definition at line 3424 of file edit.c.

3426{
3427 HMENU menu = LoadMenuA(user32_module, "EDITMENU");
3428 HMENU popup = GetSubMenu(menu, 0);
3429 UINT start = es->selection_start;
3430 UINT end = es->selection_end;
3431 UINT cmd;
3432
3434
3435 /* undo */
3437 /* cut */
3438 EnableMenuItem(popup, 2, MF_BYPOSITION | ((end - start) && !(es->style & ES_PASSWORD) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
3439 /* copy */
3440 EnableMenuItem(popup, 3, MF_BYPOSITION | ((end - start) && !(es->style & ES_PASSWORD) ? MF_ENABLED : MF_GRAYED));
3441 /* paste */
3442