ReactOS 0.4.16-dev-297-gc569aee
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:81
@ END_RICH
Definition: edit.c:82
@ END_HARD
Definition: edit.c:80
@ END_0
Definition: edit.c:78
@ END_WRAP
Definition: edit.c:79

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:414
#define EF_AFTER_WRAP
Definition: edit.c:70
static void EDIT_SetCaretPos(EDITSTATE *es, INT pos, BOOL after_wrap)
Definition: edit.c:1750
static void EDIT_BuildLineDefs_ML(EDITSTATE *es, INT istart, INT iend, INT delta, HRGN hrgn)
Definition: edit.c:429
static UINT get_text_length(EDITSTATE *es)
Definition: edit.c:216
static void EDIT_UpdateScrollInfo(EDITSTATE *es)
Definition: edit.c:1560
#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:306
static SCRIPT_STRING_ANALYSIS EDIT_UpdateUniscribeData_linedef(EDITSTATE *es, HDC dc, LINEDEF *line_def)
Definition: edit.c:330
static LRESULT EDIT_EM_PosFromChar(EDITSTATE *es, INT index, BOOL after_wrap)
Definition: edit.c:1013
static INT EDIT_CallWordBreakProc(EDITSTATE *es, INT start, INT index, INT count, INT action)
Definition: edit.c:294
#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:1794
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:89
struct tagLINEDEF * next
Definition: edit.c:92
INT length
Definition: edit.c:86
SCRIPT_STRING_ANALYSIS ssa
Definition: edit.c:91
INT index
Definition: edit.c:90
INT net_length
Definition: edit.c:87
LINE_END ending
Definition: edit.c:88
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:372
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:236
#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:7509
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:2907
int(CALLBACK * EDITWORDBREAKPROCW)(LPWSTR, int, int, int)
Definition: winuser.h:2908
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:1973
#define VK_UP
Definition: winuser.h:2228
#define VK_F4
Definition: winuser.h:2261
#define CB_GETDROPPEDSTATE
Definition: winuser.h:1948
HWND WINAPI GetParent(_In_ HWND)
#define CB_GETEXTENDEDUI
Definition: winuser.h:1951
#define VK_DOWN
Definition: winuser.h:2230
#define WM_KEYDOWN
Definition: winuser.h:1718
#define CB_SETEXTENDEDUI
Definition: winuser.h:1967
#define WM_SYSKEYDOWN
Definition: winuser.h:1722
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:1866
#define WM_CUT
Definition: winuser.h:1864
#define WM_UNDO
Definition: winuser.h:1868
#define EM_UNDO
Definition: winuser.h:2024
#define EM_SETSEL
Definition: winuser.h:2021
#define WM_COPY
Definition: winuser.h:1865
#define WM_CLEAR
Definition: winuser.h:1867

◆ 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:784
static INT EDIT_EM_LineFromChar(EDITSTATE *es, INT index)
Definition: edit.c:913
#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:71

◆ 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:59
static void EDIT_UnlockBuffer(EDITSTATE *es, BOOL force)
Definition: edit.c:1230
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:395
#define LMEM_ZEROINIT
Definition: winbase.h:401

◆ 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:942
static INT EDIT_EM_LineLength(EDITSTATE *es, INT index)
Definition: edit.c:977
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:164
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:4054
static LRESULT EDIT_WM_VScroll(EDITSTATE *es, INT action, INT pos)
Definition: edit.c:4186
#define EM_GETTHUMB
Definition: winuser.h:2001

◆ 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:1601
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:166
#define EF_HSCROLL_TRACK
Definition: edit.c:69
#define EF_VSCROLL_TRACK
Definition: edit.c:68
#define SW_INVALIDATE
Definition: winuser.h:2582
#define EN_HSCROLL
Definition: winuser.h:2027
BOOL WINAPI IntersectRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
#define EN_VSCROLL
Definition: winuser.h:2032
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:65
static void EDIT_CalcLineWidth_SL(EDITSTATE *es)
Definition: edit.c:761
static void EDIT_EM_ScrollCaret(EDITSTATE *es)
Definition: edit.c:1780
#define EF_UPDATE
Definition: edit.c:67
static void EDIT_InvalidateUniscribeData(EDITSTATE *es)
Definition: edit.c:315
static void EDIT_EM_EmptyUndoBuffer(EDITSTATE *es)
Definition: edit.c:192
static void text_buffer_changed(EDITSTATE *es)
Definition: edit.c:1198
static BOOL EDIT_MakeFit(EDITSTATE *es, UINT size)
Definition: edit.c:1276
static BOOL EDIT_MakeUndoFit(EDITSTATE *es, UINT size)
Definition: edit.c:1317
static void EDIT_UpdateTextRegion(EDITSTATE *es, HRGN hrgn, BOOL bErase)
Definition: edit.c:1344
static void EDIT_UpdateText(EDITSTATE *es, const RECT *rc, BOOL bErase)
Definition: edit.c:1359
static BOOL EDIT_EM_SetSel(EDITSTATE *es, UINT start, UINT end, BOOL after_wrap)
Definition: edit.c:1489
#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:2029
DWORD WINAPI CharUpperBuffW(_Inout_updates_(cchLength) LPWSTR lpsz, _In_ DWORD cchLength)
#define EN_CHANGE
Definition: winuser.h:2025
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:1657
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:66
#define HSCROLL_FRACTION
Definition: edit.c:60

◆ 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:1211
#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:2268
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:88
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:2610
#define EC_USEFONTINFO
Definition: winuser.h:2611
BOOL WINAPI IsRectEmpty(_In_ LPCRECT)
HDC WINAPI GetDC(_In_opt_ HWND)
#define EC_LEFTMARGIN
Definition: winuser.h:2609

◆ 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:855

◆ 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:1459

◆ 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:2492
#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:4438
static void EDIT_GetCompositionStr(HIMC hIMC, LPARAM CompFlag, EDITSTATE *es)
Definition: edit.c:4367
HIMC WINAPI ImmGetContext(HWND hWnd)
Definition: imm.c:1045
BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
Definition: imm.c:1086
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:1394
static void EDIT_SL_InvalidateText(EDITSTATE *es, INT start, INT end)
Definition: edit.c:1376

◆ 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:72

◆ 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:2026

◆ 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:1147

◆ 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:1775
#define WM_CTLCOLOREDIT
Definition: winuser.h:1770

◆ 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:2107
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:929
#define COLOR_HIGHLIGHTTEXT
Definition: winuser.h:930
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:4832
#define SM_CYBORDER
Definition: winuser.h:968
#define SM_CXBORDER
Definition: winuser.h:967
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
int WINAPI GetSystemMetrics(_In_ int)
#define GWL_EXSTYLE
Definition: winuser.h:854

◆ 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:1238
#define SB_VERT
Definition: winuser.h:553
#define SIF_PAGE
Definition: winuser.h:1236
#define SIF_DISABLENOSCROLL
Definition: winuser.h:1239
#define SIF_POS
Definition: winuser.h:1237
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:2031
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:2977
static void EDIT_MoveBackward(EDITSTATE *es, BOOL extend)
Definition: edit.c:1849
static void EDIT_MoveHome(EDITSTATE *es, BOOL extend, BOOL ctrl)
Definition: edit.c:1944
static void EDIT_WM_Clear(EDITSTATE *es)
Definition: edit.c:3053
static void EDIT_MoveDown_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:1876
#define ES_WANTRETURN
Definition: pedump.c:676
const WCHAR * str
Definition: dialog.c:52
#define VK_CONTROL
Definition: winuser.h:2206
#define VK_BACK
Definition: winuser.h:2201
#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 */
3443 /* delete */
3444 EnableMenuItem(popup, 5, MF_BYPOSITION | ((end - start) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
3445 /* select all */
3447
3448 if (x == -1 && y == -1) /* passed via VK_APPS press/release */
3449 {
3450 RECT rc;
3451 /* Windows places the menu at the edit's center in this case */
3452#ifdef __REACTOS__
3453 /* ReactOS r55202 */
3454 GetClientRect(es->hwndSelf, &rc);
3455 MapWindowPoints(es->hwndSelf, 0, (POINT *)&rc, 2);
3456#else
3457 WIN_GetRectangles( es->hwndSelf, COORDS_SCREEN, NULL, &rc );
3458#endif
3459 x = rc.left + (rc.right - rc.left) / 2;
3460 y = rc.top + (rc.bottom - rc.top) / 2;
3461 }
3462
3463 if (!(es->flags & EF_FOCUSED))
3464 SetFocus(es->hwndSelf);
3465
3467 x, y, 0, es->hwndSelf, NULL);
3468
3469 if (cmd)
3471
3472 DestroyMenu(menu);
#define CF_UNICODETEXT
Definition: constants.h:408
static BOOL EDIT_EM_CanUndo(const EDITSTATE *es)
Definition: edit.c:181
static void EDIT_ContextMenuCommand(EDITSTATE *es, UINT id)
Definition: edit.c:3167
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
Definition: ftp_var.h:139
#define user32_module
Definition: user32p.h:40
#define TPM_RIGHTBUTTON
Definition: winuser.h:2383
#define TPM_NONOTIFY
Definition: winuser.h:2389
int WINAPI MapWindowPoints(_In_opt_ HWND hWndFrom, _In_opt_ HWND hWndTo, _Inout_updates_(cPoints) LPPOINT lpPoints, _In_ UINT cPoints)
HMENU WINAPI GetSubMenu(_In_ HMENU, _In_ int)
HWND WINAPI SetFocus(_In_opt_ HWND)
#define MF_ENABLED
Definition: winuser.h:128
#define TPM_LEFTALIGN
Definition: winuser.h:2380
#define MF_BYPOSITION
Definition: winuser.h:203
BOOL WINAPI DestroyMenu(_In_ HMENU)
BOOL WINAPI TrackPopupMenu(_In_ HMENU, _In_ UINT, _In_ int, _In_ int, _Reserved_ int, _In_ HWND, _Reserved_ LPCRECT)
#define TPM_RETURNCMD
Definition: winuser.h:2390
BOOL WINAPI EnableMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
BOOL WINAPI IsClipboardFormatAvailable(_In_ UINT)
#define MF_GRAYED
Definition: winuser.h:129
HMENU WINAPI LoadMenuA(_In_opt_ HINSTANCE, _In_ LPCSTR)

◆ EDIT_WM_Copy()

static void EDIT_WM_Copy ( EDITSTATE es)
static

Definition at line 3233 of file edit.c.

3235{
3236 INT s = min(es->selection_start, es->selection_end);
3237 INT e = max(es->selection_start, es->selection_end);
3238 HGLOBAL hdst;
3239 LPWSTR dst;
3240 DWORD len;
3241
3242 if (e == s) return;
3243
3244 len = e - s;
3245 hdst = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (len + 1) * sizeof(WCHAR));
3246 dst = GlobalLock(hdst);
3247 memcpy(dst, es->text + s, len * sizeof(WCHAR));
3248 dst[len] = 0; /* ensure 0 termination */
3249 TRACE("%s\n", debugstr_w(dst));
3250 GlobalUnlock(hdst);
3251 OpenClipboard(es->hwndSelf);
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:368
#define GMEM_MOVEABLE
Definition: winbase.h:320
#define GMEM_DDESHARE
Definition: winbase.h:324
HANDLE WINAPI SetClipboardData(_In_ UINT, _In_opt_ HANDLE)
BOOL WINAPI CloseClipboard(void)
Definition: ntwrapper.h:178
BOOL WINAPI OpenClipboard(_In_opt_ HWND)
BOOL WINAPI EmptyClipboard(void)
Definition: ntwrapper.h:190

◆ EDIT_WM_Create()

static LRESULT EDIT_WM_Create ( EDITSTATE es,
LPCWSTR  name 
)
static

Definition at line 4761 of file edit.c.

4763{
4764 RECT clientRect;
4765
4766 TRACE("%s\n", debugstr_w(name));
4767 /*
4768 * To initialize some final structure members, we call some helper
4769 * functions. However, since the EDITSTATE is not consistent (i.e.
4770 * not fully initialized), we should be very careful which
4771 * functions can be called, and in what order.
4772 */
4775
4776 /* We need to calculate the format rect
4777 (applications may send EM_SETMARGINS before the control gets visible) */
4778 GetClientRect(es->hwndSelf, &clientRect);
4779 EDIT_SetRectNP(es, &clientRect);
4780
4781 if (name && *name) {
4783 /* if we insert text to the editline, the text scrolls out
4784 * of the window, as the caret is placed after the insert
4785 * pos normally; thus we reset es->selection... to 0 and
4786 * update caret
4787 */
4788 es->selection_start = es->selection_end = 0;
4789 /* Adobe Photoshop does NOT like this. and MSDN says that EN_CHANGE
4790 * Messages are only to be sent when the USER does something to
4791 * change the contents. So I am removing this EN_CHANGE
4792 *
4793 * EDIT_NOTIFY_PARENT(es, EN_CHANGE);
4794 */
4796 }
4797 /* force scroll info update */
4799 /* The rule seems to return 1 here for success */
4800 /* Power Builder masked edit controls will crash */
4801 /* if not. */
4802 /* FIXME: is that in all cases so ? */
4803 return 1;
static void EDIT_WM_SetFont(EDITSTATE *es, HFONT font, BOOL redraw)
Definition: edit.c:3829
static void EDIT_SetRectNP(EDITSTATE *es, const RECT *rc)
Definition: edit.c:2319
Definition: name.c:39

◆ EDIT_WM_Cut()

static void EDIT_WM_Cut ( EDITSTATE es)
inlinestatic

Definition at line 3277 of file edit.c.

3279{
static void EDIT_WM_Copy(EDITSTATE *es)
Definition: edit.c:3024

◆ EDIT_WM_GetText()

static INT EDIT_WM_GetText ( const EDITSTATE es,
INT  count,
LPWSTR  dst,
BOOL  unicode 
)
static

Definition at line 3480 of file edit.c.

3482{
3483 if(!count) return 0;
3484
3485 if(unicode)
3486 {
3487 lstrcpynW(dst, es->text, count);
3488 return strlenW(dst);
3489 }
3490 else
3491 {
3492 LPSTR textA = (LPSTR)dst;
3493 if (!WideCharToMultiByte(CP_ACP, 0, es->text, -1, textA, count, NULL, NULL))
3494 textA[count - 1] = 0; /* ensure 0 termination */
3495 return strlen(textA);
3496 }
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define lstrcpynW
Definition: compat.h:738

◆ EDIT_WM_HScroll()

static LRESULT EDIT_WM_HScroll ( EDITSTATE es,
INT  action,
INT  pos 
)
static

Definition at line 4228 of file edit.c.

4230{
4231 INT dx;
4232 INT fw;
4233
4234 if (!(es->style & ES_MULTILINE))
4235 return 0;
4236
4237 if (!(es->style & ES_AUTOHSCROLL))
4238 return 0;
4239
4240 dx = 0;
4241 fw = es->format_rect.right - es->format_rect.left;
4242 switch (action) {
4243 case SB_LINELEFT:
4244 TRACE("SB_LINELEFT\n");
4245 if (es->x_offset)
4246 dx = -es->char_width;
4247 break;
4248 case SB_LINERIGHT:
4249 TRACE("SB_LINERIGHT\n");
4250 if (es->x_offset < es->text_width)
4251 dx = es->char_width;
4252 break;
4253 case SB_PAGELEFT:
4254 TRACE("SB_PAGELEFT\n");
4255 if (es->x_offset)
4256 dx = -fw / HSCROLL_FRACTION / es->char_width * es->char_width;
4257 break;
4258 case SB_PAGERIGHT:
4259 TRACE("SB_PAGERIGHT\n");
4260 if (es->x_offset < es->text_width)
4261 dx = fw / HSCROLL_FRACTION / es->char_width * es->char_width;
4262 break;
4263 case SB_LEFT:
4264 TRACE("SB_LEFT\n");
4265 if (es->x_offset)
4266 dx = -es->x_offset;
4267 break;
4268 case SB_RIGHT:
4269 TRACE("SB_RIGHT\n");
4270 if (es->x_offset < es->text_width)
4271 dx = es->text_width - es->x_offset;
4272 break;
4273 case SB_THUMBTRACK:
4274 TRACE("SB_THUMBTRACK %d\n", pos);
4275 es->flags |= EF_HSCROLL_TRACK;
4276 if(es->style & WS_HSCROLL)
4277 dx = pos - es->x_offset;
4278 else
4279 {
4280 INT fw, new_x;
4281 /* Sanity check */
4282 if(pos < 0 || pos > 100) return 0;
4283 /* Assume default scroll range 0-100 */
4284 fw = es->format_rect.right - es->format_rect.left;
4285 new_x = pos * (es->text_width - fw) / 100;
4286 dx = es->text_width ? (new_x - es->x_offset) : 0;
4287 }
4288 break;
4289 case SB_THUMBPOSITION:
4290 TRACE("SB_THUMBPOSITION %d\n", pos);
4291 es->flags &= ~EF_HSCROLL_TRACK;
4292 if(GetWindowLongW( es->hwndSelf, GWL_STYLE ) & WS_HSCROLL)
4293 dx = pos - es->x_offset;
4294 else
4295 {
4296 INT fw, new_x;
4297 /* Sanity check */
4298 if(pos < 0 || pos > 100) return 0;
4299 /* Assume default scroll range 0-100 */
4300 fw = es->format_rect.right - es->format_rect.left;
4301 new_x = pos * (es->text_width - fw) / 100;
4302 dx = es->text_width ? (new_x - es->x_offset) : 0;
4303 }
4304 if (!dx) {
4305 /* force scroll info update */
4308 }
4309 break;
4310 case SB_ENDSCROLL:
4311 TRACE("SB_ENDSCROLL\n");
4312 break;
4313 /*
4314 * FIXME : the next two are undocumented !
4315 * Are we doing the right thing ?
4316 * At least Win 3.1 Notepad makes use of EM_GETTHUMB this way,
4317 * although it's also a regular control message.
4318 */
4319 case EM_GETTHUMB: /* this one is used by NT notepad */
4320 {
4321 LRESULT ret;
4322 if(GetWindowLongW( es->hwndSelf, GWL_STYLE ) & WS_HSCROLL)
4323 ret = GetScrollPos(es->hwndSelf, SB_HORZ);
4324 else
4325 {
4326 /* Assume default scroll range 0-100 */
4327 INT fw = es->format_rect.right - es->format_rect.left;
4328 ret = es->text_width ? es->x_offset * 100 / (es->text_width - fw) : 0;
4329 }
4330 TRACE("EM_GETTHUMB: returning %ld\n", ret);
4331 return ret;
4332 }
4333 case EM_LINESCROLL:
4334 TRACE("EM_LINESCROLL16\n");
4335 dx = pos;
4336 break;
4337
4338 default:
4339 ERR("undocumented WM_HSCROLL action %d (0x%04x), please report\n",
4340 action, action);
4341 return 0;
4342 }
4343 if (dx)
4344 {
4345 INT fw = es->format_rect.right - es->format_rect.left;
4346 /* check if we are going to move too far */
4347 if(es->x_offset + dx + fw > es->text_width)
4348 dx = es->text_width - fw - es->x_offset;
4349 if(dx)
4351 }
4352 return 0;
#define SB_THUMBTRACK
Definition: winuser.h:573
#define SB_PAGERIGHT
Definition: winuser.h:571
#define SB_LEFT
Definition: winuser.h:575
#define SB_LINERIGHT
Definition: winuser.h:567
#define EM_LINESCROLL
Definition: winuser.h:2007
#define SB_LINELEFT
Definition: winuser.h:566
#define SB_ENDSCROLL
Definition: winuser.h:574
#define SB_RIGHT
Definition: winuser.h:576
int WINAPI GetScrollPos(_In_ HWND, _In_ int)
#define SB_PAGELEFT
Definition: winuser.h:570
#define SB_THUMBPOSITION
Definition: winuser.h:572

◆ EDIT_WM_KeyDown()

static LRESULT EDIT_WM_KeyDown ( EDITSTATE es,
INT  key 
)
static

Definition at line 3565 of file edit.c.

3567{
3568 BOOL shift;
3569 BOOL control;
3570
3571 if (GetKeyState(VK_MENU) & 0x8000)
3572 return 0;
3573
3574 shift = GetKeyState(VK_SHIFT) & 0x8000;
3575 control = GetKeyState(VK_CONTROL) & 0x8000;
3576
3577 switch (key) {
3578 case VK_F4:
3579 case VK_UP:
3581 break;
3582
3583 /* fall through */
3584 case VK_LEFT:
3585 if ((es->style & ES_MULTILINE) && (key == VK_UP))
3587 else
3588 if (control)
3590 else
3592 break;
3593 case VK_DOWN:
3595 break;
3596 /* fall through */
3597 case VK_RIGHT:
3598 if ((es->style & ES_MULTILINE) && (key == VK_DOWN))
3600 else if (control)
3602 else
3604 break;
3605 case VK_HOME:
3607 break;
3608 case VK_END:
3610 break;
3611 case VK_PRIOR:
3612 if (es->style & ES_MULTILINE)
3614 else
3616 break;
3617 case VK_NEXT:
3618 if (es->style & ES_MULTILINE)
3620 else
3622 break;
3623 case VK_DELETE:
3624 if (!(es->style & ES_READONLY) && !(shift && control)) {
3625 if (es->selection_start != es->selection_end) {
3626 if (shift)
3627 EDIT_WM_Cut(es);
3628 else
3630 } else {
3631 if (shift) {
3632 /* delete character left of caret */
3633 EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
3636 } else if (control) {
3637 /* delete to end of line */
3638 EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
3641 } else {
3642 /* delete character right of caret */
3643 EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
3646 }
3647 }
3648 }
3649 break;
3650 case VK_INSERT:
3651 if (shift) {
3652 if (!(es->style & ES_READONLY))
3654 } else if (control)
3656 break;
3657 case VK_RETURN:
3658 /* If the edit doesn't want the return send a message to the default object */
3659 if(!(es->style & ES_MULTILINE) || !(es->style & ES_WANTRETURN))
3660 {
3661 DWORD dw;
3662
3663 if (!EDIT_IsInsideDialog(es)) break;
3664 if (control) break;
3665 dw = SendMessageW(es->hwndParent, DM_GETDEFID, 0, 0);
3666 if (HIWORD(dw) == DC_HASDEFID)
3667 {
3668 HWND hwDefCtrl = GetDlgItem(es->hwndParent, LOWORD(dw));
3669 if (hwDefCtrl)
3670 {
3671 SendMessageW(es->hwndParent, WM_NEXTDLGCTL, (WPARAM)hwDefCtrl, TRUE);
3672 PostMessageW(hwDefCtrl, WM_KEYDOWN, VK_RETURN, 0);
3673 }
3674 }
3675 }
3676 break;
3677 case VK_ESCAPE:
3678 if ((es->style & ES_MULTILINE) && EDIT_IsInsideDialog(es))
3679 PostMessageW(es->hwndParent, WM_CLOSE, 0, 0);
3680 break;
3681 case VK_TAB:
3682 if ((es->style & ES_MULTILINE) && EDIT_IsInsideDialog(es))
3683 SendMessageW(es->hwndParent, WM_NEXTDLGCTL, shift, 0);
3684 break;
3685#ifdef __REACTOS__
3686 /* ReactOS CORE-1419 */
3687 case VK_BACK:
3688 if (control)
3689 {
3690 FIXME("Ctrl+Backspace\n");
3691 }
3692 break;
3693#endif
3694 }
3695 return TRUE;
static void EDIT_MoveEnd(EDITSTATE *es, BOOL extend, BOOL ctrl)
Definition: edit.c:1898
static BOOL EDIT_CheckCombo(EDITSTATE *es, UINT msg, INT key)
Definition: edit.c:3281
static void EDIT_MoveUp_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:2024
static void EDIT_WM_Cut(EDITSTATE *es)
Definition: edit.c:3068
static void EDIT_MovePageUp_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:1996
static void EDIT_WM_Paste(EDITSTATE *es)
Definition: edit.c:2988
static void EDIT_MovePageDown_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:1968
static void EDIT_MoveWordForward(EDITSTATE *es, BOOL extend)
Definition: edit.c:2077
static void EDIT_MoveWordBackward(EDITSTATE *es, BOOL extend)
Definition: edit.c:2046
static void EDIT_MoveForward(EDITSTATE *es, BOOL extend)
Definition: edit.c:1919
REFIID LPVOID DWORD_PTR dw
Definition: atlbase.h:40
#define shift
Definition: input.c:1755
#define WM_CLOSE
Definition: winuser.h:1624
#define VK_TAB
Definition: winuser.h:2202
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define DC_HASDEFID
Definition: winuser.h:2612
HWND WINAPI GetDlgItem(_In_opt_ HWND, _In_ int)
#define WM_NEXTDLGCTL
Definition: winuser.h:1646
#define VK_NEXT
Definition: winuser.h:2224
#define VK_RETURN
Definition: winuser.h:2204
#define VK_END
Definition: winuser.h:2225
#define VK_HOME
Definition: winuser.h:2226
#define VK_LEFT
Definition: winuser.h:2227
#define VK_RIGHT
Definition: winuser.h:2229
#define VK_SHIFT
Definition: winuser.h:2205
#define VK_PRIOR
Definition: winuser.h:2223
#define VK_DELETE
Definition: winuser.h:2236
#define DM_GETDEFID
Definition: winuser.h:2101
#define VK_ESCAPE
Definition: winuser.h:2217
#define VK_INSERT
Definition: winuser.h:2235
#define VK_MENU
Definition: winuser.h:2207

◆ EDIT_WM_KillFocus()

static LRESULT EDIT_WM_KillFocus ( EDITSTATE es)
static

Definition at line 3703 of file edit.c.

3705{
3706#ifdef __REACTOS__
3707 HWND hCombo;
3708 LONG lStyles;
3709
3710 es->flags &= ~EF_FOCUSED;
3711 DestroyCaret();
3712 if(!(es->style & ES_NOHIDESEL))
3713 EDIT_InvalidateText(es, es->selection_start, es->selection_end);
3714
3715 /* throw away left over scroll when we lose focus */
3716 es->wheelDeltaRemainder = 0;
3717
3718 if (es->hwndListBox == NULL) {
3719 if (!notify_parent(es, EN_KILLFOCUS)) return 0;
3720 } else
3721 { /* send the undocumented WM_CBLOSTTEXTFOCUS message to combobox */
3722 hCombo = GetParent(es->hwndSelf);
3723 lStyles = GetWindowLong(hCombo, GWL_STYLE);
3724 if ((lStyles & CBS_DROPDOWN) || (lStyles & CBS_SIMPLE))
3725 SendMessage(hCombo, WM_CBLOSTTEXTFOCUS, 0, 0);
3726 }
3727#else
3728 es->flags &= ~EF_FOCUSED;
3729 DestroyCaret();
3730 if(!(es->style & ES_NOHIDESEL))
3731 EDIT_InvalidateText(es, es->selection_start, es->selection_end);
3732 if (!notify_parent(es, EN_KILLFOCUS)) return 0;
3733 /* throw away left over scroll when we lose focus */
3734 es->wheelDeltaRemainder = 0;
3735#endif
3736 return 0;
#define WM_CBLOSTTEXTFOCUS
Definition: undocuser.h:50
#define EN_KILLFOCUS
Definition: winuser.h:2028
#define CBS_SIMPLE
Definition: winuser.h:291
#define SendMessage
Definition: winuser.h:5855
#define CBS_DROPDOWN
Definition: winuser.h:283
#define GetWindowLong
Definition: winuser.h:5808
BOOL WINAPI DestroyCaret(void)
Definition: caret.c:35

◆ EDIT_WM_LButtonDblClk()

static LRESULT EDIT_WM_LButtonDblClk ( EDITSTATE es)
static

Definition at line 3746 of file edit.c.

3748{
3749 INT s;
3750 INT e = es->selection_end;
3751 INT l;
3752 INT li;
3753 INT ll;
3754
3755 es->bCaptureState = TRUE;
3756 SetCapture(es->hwndSelf);
3757
3765 es->region_posx = es->region_posy = 0;
3766 SetTimer(es->hwndSelf, 0, 100, NULL);
3767 return 0;
HWND WINAPI SetCapture(_In_ HWND hWnd)
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)

◆ EDIT_WM_LButtonDown()

static LRESULT EDIT_WM_LButtonDown ( EDITSTATE es,
DWORD  keys,
INT  x,
INT  y 
)
static

Definition at line 3775 of file edit.c.

3777{
3778 INT e;
3779 BOOL after_wrap;
3780
3781 es->bCaptureState = TRUE;
3782 SetCapture(es->hwndSelf);
3783 EDIT_ConfinePoint(es, &x, &y);
3784 e = EDIT_CharFromPos(es, x, y, &after_wrap);
3785 EDIT_EM_SetSel(es, (keys & MK_SHIFT) ? es->selection_start : e, e, after_wrap);
3787 es->region_posx = es->region_posy = 0;
3788 SetTimer(es->hwndSelf, 0, 100, NULL);
3789
3790 if (!(es->flags & EF_FOCUSED))
3791 SetFocus(es->hwndSelf);
3792
3793 return 0;
static void EDIT_ConfinePoint(const EDITSTATE *es, LPINT x, LPINT y)
Definition: edit.c:901
#define MK_SHIFT
Definition: winuser.h:2372

◆ EDIT_WM_LButtonUp()

static LRESULT EDIT_WM_LButtonUp ( EDITSTATE es)
static

Definition at line 3801 of file edit.c.

3803{
3804 if (es->bCaptureState) {
3805 KillTimer(es->hwndSelf, 0);
3806 if (GetCapture() == es->hwndSelf) ReleaseCapture();
3807 }
3808 es->bCaptureState = FALSE;
3809 return 0;
BOOL WINAPI ReleaseCapture(void)
Definition: message.c:2890
HWND WINAPI GetCapture(void)
Definition: message.c:2881
BOOL WINAPI KillTimer(_In_opt_ HWND, _In_ UINT_PTR)

◆ EDIT_WM_MButtonDown()

static LRESULT EDIT_WM_MButtonDown ( EDITSTATE es)
static

Definition at line 3817 of file edit.c.

3819{
3820 SendMessageW(es->hwndSelf, WM_PASTE, 0, 0);
3821 return 0;

◆ EDIT_WM_MouseMove()

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

Definition at line 3829 of file edit.c.

3831{
3832 INT e;
3833 BOOL after_wrap;
3834 INT prex, prey;
3835
3836 /* If the mouse has been captured by process other than the edit control itself,
3837 * the windows edit controls will not select the strings with mouse move.
3838 */
3839 if (!es->bCaptureState || GetCapture() != es->hwndSelf)
3840 return 0;
3841
3842 /*
3843 * FIXME: gotta do some scrolling if outside client
3844 * area. Maybe reset the timer ?
3845 */
3846 prex = x; prey = y;
3847 EDIT_ConfinePoint(es, &x, &y);
3848 es->region_posx = (prex < x) ? -1 : ((prex > x) ? 1 : 0);
3849 es->region_posy = (prey < y) ? -1 : ((prey > y) ? 1 : 0);
3850 e = EDIT_CharFromPos(es, x, y, &after_wrap);
3851 EDIT_EM_SetSel(es, es->selection_start, e, after_wrap);
3852 EDIT_SetCaretPos(es,es->selection_end,es->flags & EF_AFTER_WRAP);
3853 return 0;

◆ EDIT_WM_NCCreate()

static LRESULT EDIT_WM_NCCreate ( HWND  hwnd,
LPCREATESTRUCTW  lpcs,
BOOL  unicode 
)
static

Definition at line 4646 of file edit.c.

4648{
4649 EDITSTATE *es;
4650 UINT alloc_size;
4651
4652 TRACE("Creating %s edit control, style = %08x\n",
4653 unicode ? "Unicode" : "ANSI", lpcs->style);
4654
4655 if (!(es = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*es))))
4656 return FALSE;
4658
4659 /*
4660 * Note: since the EDITSTATE has not been fully initialized yet,
4661 * we can't use any API calls that may send
4662 * WM_XXX messages before WM_NCCREATE is completed.
4663 */
4664
4665 es->is_unicode = unicode;
4666 es->style = lpcs->style;
4667
4668 es->bEnableState = !(es->style & WS_DISABLED);
4669
4670 es->hwndSelf = hwnd;
4671 /* Save parent, which will be notified by EN_* messages */
4672 es->hwndParent = lpcs->hwndParent;
4673
4674 if (es->style & ES_COMBO)
4675 es->hwndListBox = GetDlgItem(es->hwndParent, ID_CB_LISTBOX);
4676
4677 /* FIXME: should we handle changes to WS_EX_RIGHT style after creation? */
4678 if (lpcs->dwExStyle & WS_EX_RIGHT) es->style |= ES_RIGHT;
4679
4680 /* Number overrides lowercase overrides uppercase (at least it
4681 * does in Win95). However I'll bet that ES_NUMBER would be
4682 * invalid under Win 3.1.
4683 */
4684 if (es->style & ES_NUMBER) {
4685 ; /* do not override the ES_NUMBER */
4686 } else if (es->style & ES_LOWERCASE) {
4687 es->style &= ~ES_UPPERCASE;
4688 }
4689 if (es->style & ES_MULTILINE) {
4690 es->buffer_limit = BUFLIMIT_INITIAL;
4691 if (es->style & WS_VSCROLL)
4692 es->style |= ES_AUTOVSCROLL;
4693 if (es->style & WS_HSCROLL)
4694 es->style |= ES_AUTOHSCROLL;
4695 es->style &= ~ES_PASSWORD;
4696 if ((es->style & ES_CENTER) || (es->style & ES_RIGHT)) {
4697 /* Confirmed - RIGHT overrides CENTER */
4698 if (es->style & ES_RIGHT)
4699 es->style &= ~ES_CENTER;
4700 es->style &= ~WS_HSCROLL;
4701 es->style &= ~ES_AUTOHSCROLL;
4702 }
4703 } else {
4704 es->buffer_limit = BUFLIMIT_INITIAL;
4705 if ((es->style & ES_RIGHT) && (es->style & ES_CENTER))
4706 es->style &= ~ES_CENTER;
4707 es->style &= ~WS_HSCROLL;
4708 es->style &= ~WS_VSCROLL;
4709 if (es->style & ES_PASSWORD)
4710 es->password_char = '*';
4711 }
4712
4713 alloc_size = ROUND_TO_GROW((es->buffer_size + 1) * sizeof(WCHAR));
4714 if(!(es->hloc32W = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, alloc_size)))
4715 goto cleanup;
4716 es->buffer_size = LocalSize(es->hloc32W)/sizeof(WCHAR) - 1;
4717
4718 if (!(es->undo_text = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (es->buffer_size + 1) * sizeof(WCHAR))))
4719 goto cleanup;
4720 es->undo_buffer_size = es->buffer_size;
4721
4722 if (es->style & ES_MULTILINE)
4723 if (!(es->first_line_def = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LINEDEF))))
4724 goto cleanup;
4725 es->line_count = 1;
4726
4727 /*
4728 * In Win95 look and feel, the WS_BORDER style is replaced by the
4729 * WS_EX_CLIENTEDGE style for the edit control. This gives the edit
4730 * control a nonclient area so we don't need to draw the border.
4731 * If WS_BORDER without WS_EX_CLIENTEDGE is specified we shouldn't have
4732 * a nonclient area and we should handle painting the border ourselves.
4733 *
4734 * When making modifications please ensure that the code still works
4735 * for edit controls created directly with style 0x50800000, exStyle 0
4736 * (which should have a single pixel border)
4737 */
4738 if (lpcs->dwExStyle & WS_EX_CLIENTEDGE)
4739 es->style &= ~WS_BORDER;
4740 else if (es->style & WS_BORDER)
4742
4743 return TRUE;
4744
4745cleanup:
4746 SetWindowLongPtrW(es->hwndSelf, 0, 0);
4748 HeapFree(GetProcessHeap(), 0, es->first_line_def);
4749 HeapFree(GetProcessHeap(), 0, es->undo_text);
4750 if (es->hloc32W) LocalFree(es->hloc32W);
4751 HeapFree(GetProcessHeap(), 0, es->logAttr);
4752 HeapFree(GetProcessHeap(), 0, es);
4753 return FALSE;
#define ID_CB_LISTBOX
Definition: edit.c:74
#define BUFLIMIT_INITIAL
Definition: edit.c:57
static void cleanup(void)
Definition: main.c:1335
#define ES_COMBO
Definition: edit.c:29
#define WS_DISABLED
Definition: pedump.c:621
Definition: edit.c:96
#define SetWindowLongPtrW
Definition: winuser.h:5358
#define WS_EX_RIGHT
Definition: winuser.h:400

◆ EDIT_WM_NCDestroy()

static LRESULT EDIT_WM_NCDestroy ( EDITSTATE es)
static

Definition at line 4811 of file edit.c.

4813{
4814 LINEDEF *pc, *pp;
4815
4816 /* The app can own the text buffer handle */
4817 if (es->hloc32W && (es->hloc32W != es->hlocapp)) {
4818 LocalFree(es->hloc32W);
4819 }
4820 if (es->hloc32A && (es->hloc32A != es->hlocapp)) {
4821 LocalFree(es->hloc32A);
4822 }
4824 pc = es->first_line_def;
4825 while (pc)
4826 {
4827 pp = pc->next;
4828 HeapFree(GetProcessHeap(), 0, pc);
4829 pc = pp;
4830 }
4831
4832 SetWindowLongPtrW( es->hwndSelf, 0, 0 );
4833 HeapFree(GetProcessHeap(), 0, es->undo_text);
4834 HeapFree(GetProcessHeap(), 0, es);
4835
4836 return 0;

◆ EDIT_WM_Paint()

static void EDIT_WM_Paint ( EDITSTATE es,
HDC  hdc 
)
static

Definition at line 3861 of file edit.c.

3863{
3864 PAINTSTRUCT ps;
3865 INT i;
3866 HDC dc;
3867 HFONT old_font = 0;
3868 RECT rc;
3869 RECT rcClient;
3870 RECT rcLine;
3871 RECT rcRgn;
3872 HBRUSH brush;
3873 HBRUSH old_brush;
3874 INT bw, bh;
3875 BOOL rev = es->bEnableState &&
3876 ((es->flags & EF_FOCUSED) ||
3877 (es->style & ES_NOHIDESEL));
3878 dc = hdc ? hdc : BeginPaint(es->hwndSelf, &ps);
3879
3880 /* The dc we use for calculating may not be the one we paint into.
3881 This is the safest action. */
3883 GetClientRect(es->hwndSelf, &rcClient);
3884
3885 /* get the background brush */
3886 brush = EDIT_NotifyCtlColor(es, dc);
3887
3888 /* paint the border and the background */
3889 IntersectClipRect(dc, rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
3890
3891 if(es->style & WS_BORDER) {
3894 rc = rcClient;
3895 if(es->style & ES_MULTILINE) {
3896 if(es->style & WS_HSCROLL) rc.bottom+=bh;
3897 if(es->style & WS_VSCROLL) rc.right+=bw;
3898 }
3899
3900 /* Draw the frame. Same code as in nonclient.c */
3902 PatBlt(dc, rc.left, rc.top, rc.right - rc.left, bh, PATCOPY);
3903 PatBlt(dc, rc.left, rc.top, bw, rc.bottom - rc.top, PATCOPY);
3904 PatBlt(dc, rc.left, rc.bottom - 1, rc.right - rc.left, -bw, PATCOPY);
3905 PatBlt(dc, rc.right - 1, rc.top, -bw, rc.bottom - rc.top, PATCOPY);
3906 SelectObject(dc, old_brush);
3907
3908 /* Keep the border clean */
3909 IntersectClipRect(dc, rc.left+bw, rc.top+bh,
3910 max(rc.right-bw, rc.left+bw), max(rc.bottom-bh, rc.top+bh));
3911 }
3912
3913 GetClipBox(dc, &rc);
3914 FillRect(dc, &rc, brush);
3915
3916 IntersectClipRect(dc, es->format_rect.left,
3917 es->format_rect.top,
3918 es->format_rect.right,
3919 es->format_rect.bottom);
3920 if (es->style & ES_MULTILINE) {
3921 rc = rcClient;
3922 IntersectClipRect(dc, rc.left, rc.top, rc.right, rc.bottom);
3923 }
3924 if (es->font)
3925 old_font = SelectObject(dc, es->font);
3926
3927 if (!es->bEnableState)
3929 GetClipBox(dc, &rcRgn);
3930 if (es->style & ES_MULTILINE) {
3932 for (i = es->y_offset ; i <= min(es->y_offset + vlc, es->y_offset + es->line_count - 1) ; i++) {
3934 EDIT_GetLineRect(es, i, 0, -1, &rcLine);
3935 if (IntersectRect(&rc, &rcRgn, &rcLine))
3936 EDIT_PaintLine(es, dc, i, rev);
3937 }
3938 } else {
3940 EDIT_GetLineRect(es, 0, 0, -1, &rcLine);
3941 if (IntersectRect(&rc, &rcRgn, &rcLine))
3942 EDIT_PaintLine(es, dc, 0, rev);
3943 }
3944 if (es->font)
3945 SelectObject(dc, old_font);
3946
3947 if (!hdc)
3948 EndPaint(es->hwndSelf, &ps);
static void EDIT_PaintLine(EDITSTATE *es, HDC dc, INT line, BOOL rev)
Definition: edit.c:2181
static HBRUSH EDIT_NotifyCtlColor(EDITSTATE *es, HDC hdc)
Definition: edit.c:198
int WINAPI GetClipBox(_In_ HDC, _Out_ LPRECT)
int WINAPI IntersectClipRect(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
#define PATCOPY
Definition: wingdi.h:335
BOOL WINAPI PatBlt(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_ DWORD)
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
#define COLOR_GRAYTEXT
Definition: winuser.h:935
#define COLOR_WINDOWFRAME
Definition: winuser.h:922
HBRUSH WINAPI GetSysColorBrush(_In_ int)
BOOL WINAPI EndPaint(_In_ HWND, _In_ const PAINTSTRUCT *)
HDC WINAPI BeginPaint(_In_ HWND, _Out_ LPPAINTSTRUCT)

◆ EDIT_WM_Paste()

static void EDIT_WM_Paste ( EDITSTATE es)
static

Definition at line 3205 of file edit.c.

3207{
3208 HGLOBAL hsrc;
3209 LPWSTR src;
3210
3211 /* Protect read-only edit control from modification */
3212 if(es->style & ES_READONLY)
3213 return;
3214
3215 OpenClipboard(es->hwndSelf);
3216 if ((hsrc = GetClipboardData(CF_UNICODETEXT))) {
3217 src = GlobalLock(hsrc);
3219 GlobalUnlock(hsrc);
3220 }
3221 else if (es->style & ES_PASSWORD) {
3222 /* clear selected text in password edit box even with empty clipboard */
3224 }
HANDLE WINAPI GetClipboardData(_In_ UINT)

◆ EDIT_WM_SetFocus()

static void EDIT_WM_SetFocus ( EDITSTATE es)
static

Definition at line 3956 of file edit.c.

3958{
3959 es->flags |= EF_FOCUSED;
3960
3961 if (!(es->style & ES_NOHIDESEL))
3962 EDIT_InvalidateText(es, es->selection_start, es->selection_end);
3963
3964 /* single line edit updates itself */
3965 if (IsWindowVisible(es->hwndSelf) && !(es->style & ES_MULTILINE))
3966 {
3967 HDC hdc = GetDC(es->hwndSelf);
3969 ReleaseDC(es->hwndSelf, hdc);
3970 }
3971
3972#ifdef __REACTOS__
3973 SystemParametersInfo(SPI_GETCARETWIDTH, 0, &es->dwCaretWidth, 0);
3974 CreateCaret(es->hwndSelf, NULL, es->dwCaretWidth, es->line_height);
3975#else
3976 CreateCaret(es->hwndSelf, 0, 1, es->line_height);
3977#endif
3978 EDIT_SetCaretPos(es, es->selection_end,
3979 es->flags & EF_AFTER_WRAP);
3980 ShowCaret(es->hwndSelf);
static void EDIT_WM_Paint(EDITSTATE *es, HDC hdc)
Definition: edit.c:3620
BOOL WINAPI ShowCaret(_In_opt_ HWND)
#define EN_SETFOCUS
Definition: winuser.h:2030
BOOL WINAPI CreateCaret(_In_ HWND, _In_opt_ HBITMAP, _In_ int, _In_ int)
#define SystemParametersInfo
Definition: winuser.h:5870
BOOL WINAPI IsWindowVisible(_In_ HWND)

◆ EDIT_WM_SetFont()

static void EDIT_WM_SetFont ( EDITSTATE es,
HFONT  font,
BOOL  redraw 
)
static

Definition at line 3993 of file edit.c.

3995{
3997 HDC dc;
3998 HFONT old_font = 0;
3999 RECT clientRect;
4000
4001 es->font = font;
4003 dc = GetDC(es->hwndSelf);
4004 if (font)
4005 old_font = SelectObject(dc, font);
4007 es->line_height = tm.tmHeight;
4008 es->char_width = tm.tmAveCharWidth;
4009 if (font)
4010 SelectObject(dc, old_font);
4011 ReleaseDC(es->hwndSelf, dc);
4012
4013 /* Reset the format rect and the margins */
4014 GetClientRect(es->hwndSelf, &clientRect);
4015 EDIT_SetRectNP(es, &clientRect);
4018
4019 if (es->style & ES_MULTILINE)
4021 else
4023
4024 if (redraw)
4026 if (es->flags & EF_FOCUSED) {
4027 DestroyCaret();
4028#ifdef __REACTOS__
4029 CreateCaret(es->hwndSelf, NULL, es->dwCaretWidth, es->line_height);
4030#else
4031 CreateCaret(es->hwndSelf, 0, 1, es->line_height);
4032#endif
4033 EDIT_SetCaretPos(es, es->selection_end,
4034 es->flags & EF_AFTER_WRAP);
4035 ShowCaret(es->hwndSelf);
4036 }
4037#ifdef __REACTOS__
4039 {
4040 LOGFONTW lf;
4041 HIMC hIMC = ImmGetContext(es->hwndSelf);
4042 if (font == NULL)
4044 GetObjectW(font, sizeof(lf), &lf);
4045 ImmSetCompositionFontW(hIMC, &lf);
4046 ImmReleaseContext(es->hwndSelf, hIMC);
4047 }
4048#endif
static void EDIT_EM_SetMargins(EDITSTATE *es, INT action, WORD left, WORD right, BOOL repaint)
Definition: edit.c:2794
BOOL WINAPI ImmSetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
Definition: ime.c:1744
Definition: mk_font.cpp:20
void redraw(int x, int y, int cx, int cy)
Definition: qtewin.cpp:1248
BOOL WINAPI GetTextMetricsW(_In_ HDC, _Out_ LPTEXTMETRICW)
Definition: text.c:221
HGDIOBJ WINAPI GetStockObject(_In_ int)
#define DEFAULT_GUI_FONT
Definition: wingdi.h:909

◆ EDIT_WM_SetText()

static void EDIT_WM_SetText ( EDITSTATE es,
LPCWSTR  text,
BOOL  unicode 
)
static

Definition at line 4063 of file edit.c.

4065{
4066 LPWSTR textW = NULL;
4067 if (!unicode && text)
4068 {
4070 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
4071 textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR));
4072 if (textW)
4073 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
4074 text = textW;
4075 }
4076
4077 if (es->flags & EF_UPDATE)
4078 /* fixed this bug once; complain if we see it about to happen again. */
4079 ERR("SetSel may generate UPDATE message whose handler may reset "
4080 "selection.\n");
4081
4082 EDIT_EM_SetSel(es, 0, (UINT)-1, FALSE);
4083 if (text)
4084 {
4085 TRACE("%s\n", debugstr_w(text));
4087 if(!unicode)
4089 }
4090 else
4091 {
4092 TRACE("<NULL>\n");
4094 }
4095 es->x_offset = 0;
4096 es->flags &= ~EF_MODIFIED;
4097 EDIT_EM_SetSel(es, 0, 0, FALSE);
4098
4099 /* Send the notification after the selection start and end have been set
4100 * edit control doesn't send notification on WM_SETTEXT
4101 * if it is multiline, or it is part of combobox
4102 */
4103 if( !((es->style & ES_MULTILINE) || es->hwndListBox))
4104 {
4105 if (!notify_parent(es, EN_UPDATE)) return;
4106 if (!notify_parent(es, EN_CHANGE)) return;
4107 }
const char * LPCSTR
Definition: xmlstorage.h:183

◆ EDIT_WM_Size()

static void EDIT_WM_Size ( EDITSTATE es,
UINT  action 
)
static

Definition at line 4118 of file edit.c.

4120{
4121 if ((action == SIZE_MAXIMIZED) || (action == SIZE_RESTORED)) {
4122 RECT rc;
4123 GetClientRect(es->hwndSelf, &rc);
4124 EDIT_SetRectNP(es, &rc);
4126 }
#define SIZE_MAXIMIZED
Definition: winuser.h:2510
#define SIZE_RESTORED
Definition: winuser.h:2508

◆ EDIT_WM_StyleChanged()

static LRESULT EDIT_WM_StyleChanged ( EDITSTATE es,
WPARAM  which,
const STYLESTRUCT style 
)
static

Definition at line 4151 of file edit.c.

4153{
4154 if (GWL_STYLE == which) {
4155 DWORD style_change_mask;
4156 DWORD new_style;
4157 /* Only a subset of changes can be applied after the control
4158 * has been created.
4159 */
4160 style_change_mask = ES_UPPERCASE | ES_LOWERCASE |
4161 ES_NUMBER;
4162 if (es->style & ES_MULTILINE)
4163 style_change_mask |= ES_WANTRETURN;
4164
4165 new_style = style->styleNew & style_change_mask;
4166
4167 /* Number overrides lowercase overrides uppercase (at least it
4168 * does in Win95). However I'll bet that ES_NUMBER would be
4169 * invalid under Win 3.1.
4170 */
4171 if (new_style & ES_NUMBER) {
4172 ; /* do not override the ES_NUMBER */
4173 } else if (new_style & ES_LOWERCASE) {
4174 new_style &= ~ES_UPPERCASE;
4175 }
4176
4177 es->style = (es->style & ~style_change_mask) | new_style;
4178 } else if (GWL_EXSTYLE == which) {
4179 ; /* FIXME - what is needed here */
4180 } else {
4181 WARN ("Invalid style change %ld\n",which);
4182 }
4183
4184 return 0;
static GLenum which
Definition: wgl_font.c:159

◆ EDIT_WM_SysKeyDown()

static LRESULT EDIT_WM_SysKeyDown ( EDITSTATE es,
INT  key,
DWORD  key_data 
)
static

Definition at line 4191 of file edit.c.

4193{
4194 if ((key == VK_BACK) && (key_data & 0x2000)) {
4195 if (EDIT_EM_CanUndo(es))
4197 return 0;
4198 } else if (key == VK_UP || key == VK_DOWN) {
4200 return 0;
4201 }
4202 return DefWindowProcW(es->hwndSelf, WM_SYSKEYDOWN, key, key_data);
static BOOL EDIT_EM_Undo(EDITSTATE *es)
Definition: edit.c:2936

◆ EDIT_WM_Timer()

static void EDIT_WM_Timer ( EDITSTATE es)
static

Definition at line 4210 of file edit.c.

4212{
4213 if (es->region_posx < 0) {
4215 } else if (es->region_posx > 0) {
4217 }
4218/*
4219 * FIXME: gotta do some vertical scrolling here, like
4220 * EDIT_EM_LineScroll(hwnd, 0, 1);
4221 */

◆ EDIT_WM_VScroll()

static LRESULT EDIT_WM_VScroll ( EDITSTATE es,
INT  action,
INT  pos 
)
static

Definition at line 4360 of file edit.c.

4362{
4363 INT dy;
4364
4365 if (!(es->style & ES_MULTILINE))
4366 return 0;
4367
4368 if (!(es->style & ES_AUTOVSCROLL))
4369 return 0;
4370
4371 dy = 0;
4372 switch (action) {
4373 case SB_LINEUP:
4374 case SB_LINEDOWN:
4375 case SB_PAGEUP:
4376 case SB_PAGEDOWN:
4377 TRACE("action %d (%s)\n", action, (action == SB_LINEUP ? "SB_LINEUP" :
4378 (action == SB_LINEDOWN ? "SB_LINEDOWN" :
4379 (action == SB_PAGEUP ? "SB_PAGEUP" :
4380 "SB_PAGEDOWN"))));
4382 return 0;
4383 case SB_TOP:
4384 TRACE("SB_TOP\n");
4385 dy = -es->y_offset;
4386 break;
4387 case SB_BOTTOM:
4388 TRACE("SB_BOTTOM\n");
4389 dy = es->line_count - 1 - es->y_offset;
4390 break;
4391 case SB_THUMBTRACK:
4392 TRACE("SB_THUMBTRACK %d\n", pos);
4393 es->flags |= EF_VSCROLL_TRACK;
4394 if(es->style & WS_VSCROLL)
4395 dy = pos - es->y_offset;
4396 else
4397 {
4398 /* Assume default scroll range 0-100 */
4399 INT vlc, new_y;
4400 /* Sanity check */
4401 if(pos < 0 || pos > 100) return 0;
4403 new_y = pos * (es->line_count - vlc) / 100;
4404 dy = es->line_count ? (new_y - es->y_offset) : 0;
4405 TRACE("line_count=%d, y_offset=%d, pos=%d, dy = %d\n",
4406 es->line_count, es->y_offset, pos, dy);
4407 }
4408 break;
4409 case SB_THUMBPOSITION:
4410 TRACE("SB_THUMBPOSITION %d\n", pos);
4411 es->flags &= ~EF_VSCROLL_TRACK;
4412 if(es->style & WS_VSCROLL)
4413 dy = pos - es->y_offset;
4414 else
4415 {
4416 /* Assume default scroll range 0-100 */
4417 INT vlc, new_y;
4418 /* Sanity check */
4419 if(pos < 0 || pos > 100) return 0;
4421 new_y = pos * (es->line_count - vlc) / 100;
4422 dy = es->line_count ? (new_y - es->y_offset) : 0;
4423 TRACE("line_count=%d, y_offset=%d, pos=%d, dy = %d\n",
4424 es->line_count, es->y_offset, pos, dy);
4425 }
4426 if (!dy)
4427 {
4428 /* force scroll info update */
4431 }
4432 break;
4433 case SB_ENDSCROLL:
4434 TRACE("SB_ENDSCROLL\n");
4435 break;
4436 /*
4437 * FIXME : the next two are undocumented !
4438 * Are we doing the right thing ?
4439 * At least Win 3.1 Notepad makes use of EM_GETTHUMB this way,
4440 * although it's also a regular control message.
4441 */
4442 case EM_GETTHUMB: /* this one is used by NT notepad */
4443 {
4444 LRESULT ret;
4445 if(GetWindowLongW( es->hwndSelf, GWL_STYLE ) & WS_VSCROLL)
4446 ret = GetScrollPos(es->hwndSelf, SB_VERT);
4447 else
4448 {
4449 /* Assume default scroll range 0-100 */
4451 ret = es->line_count ? es->y_offset * 100 / (es->line_count - vlc) : 0;
4452 }
4453 TRACE("EM_GETTHUMB: returning %ld\n", ret);
4454 return ret;
4455 }
4456 case EM_LINESCROLL:
4457 TRACE("EM_LINESCROLL %d\n", pos);
4458 dy = pos;
4459 break;
4460
4461 default:
4462 ERR("undocumented WM_VSCROLL action %d (0x%04x), please report\n",
4463 action, action);
4464 return 0;
4465 }
4466 if (dy)
4468 return 0;
static LRESULT EDIT_EM_Scroll(EDITSTATE *es, INT action)
Definition: edit.c:1672
#define SB_BOTTOM
Definition: winuser.h:577
#define SB_TOP
Definition: winuser.h:578

◆ EDIT_WordBreakProc()

static INT EDIT_WordBreakProc ( EDITSTATE es,
LPWSTR  s,
INT  index,
INT  count,
INT  action 
)
static

Definition at line 285 of file edit.c.

287{
288 INT ret = 0;
289
290 TRACE("s=%p, index=%d, count=%d, action=%d\n", s, index, count, action);
291
292 if(!s) return 0;
293
294 if (!es->logAttr)
295 {
297
298 memset(&psa,0,sizeof(SCRIPT_ANALYSIS));
299 psa.eScript = SCRIPT_UNDEFINED;
300
301 es->logAttr = HeapAlloc(GetProcessHeap(), 0, sizeof(SCRIPT_LOGATTR) * get_text_length(es));
302 ScriptBreak(es->text, get_text_length(es), &psa, es->logAttr);
303 }
304
305 switch (action) {
306 case WB_LEFT:
307 if (index)
308 index--;
309 while (index && !es->logAttr[index].fSoftBreak)
310 index--;
311 ret = index;
312 break;
313 case WB_RIGHT:
314 if (!count)
315 break;
316 while (index < count && s[index] && !es->logAttr[index].fSoftBreak)
317 index++;
318 ret = index;
319 break;
320 case WB_ISDELIMITER:
321 ret = es->logAttr[index].fWhiteSpace;
322 break;
323 default:
324 ERR("unknown action code, please report !\n");
325 break;
326 }
327 return ret;
HRESULT WINAPI ScriptBreak(const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
Definition: usp10.c:3047
static SCRIPT_CACHE SCRIPT_ANALYSIS * psa
Definition: usp10.c:64
#define memset(x, y, z)
Definition: compat.h:39
#define SCRIPT_UNDEFINED
Definition: usp10.h:69
#define WB_ISDELIMITER
Definition: winuser.h:549

◆ EditWndProc_common()

LRESULT WINAPI EditWndProc_common ( HWND  hwnd,
UINT  msg,
WPARAM  wParam,
LPARAM  lParam,
BOOL  unicode 
)

Definition at line 4854 of file edit.c.

4856{
4858 LRESULT result = 0;
4859#ifdef __REACTOS__
4860 /* ReactOS r50219 */
4861 PWND pWnd;
4862
4863 pWnd = ValidateHwnd(hwnd);
4864 if (pWnd)
4865 {
4866 if (!pWnd->fnid)
4867 {
4869 }
4870 else
4871 {
4872 if (pWnd->fnid != FNID_EDIT)
4873 {
4874 ERR("Wrong window class for Edit! fnId 0x%x\n",pWnd->fnid);
4875 return 0;
4876 }
4877 }
4878 }
4879#endif
4880
4881 TRACE("hwnd=%p msg=%x (%s) wparam=%lx lparam=%lx\n", hwnd, msg, SPY_GetMsgName(msg, hwnd), wParam, lParam);
4882
4883 if (!es && msg != WM_NCCREATE)
4884 return DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
4885
4886 if (es && (msg != WM_NCDESTROY)) EDIT_LockBuffer(es);
4887
4888 switch (msg) {
4889 case EM_GETSEL:
4891 break;
4892
4893 case EM_SETSEL:
4896 result = 1;
4897 break;
4898
4899 case EM_GETRECT:
4900 if (lParam)
4901 CopyRect((LPRECT)lParam, &es->format_rect);
4902 break;
4903
4904 case EM_SETRECT:
4905 if ((es->style & ES_MULTILINE) && lParam) {
4908 }
4909 break;
4910
4911 case EM_SETRECTNP:
4912 if ((es->style & ES_MULTILINE) && lParam)
4914 break;
4915
4916 case EM_SCROLL:
4918 break;
4919
4920 case EM_LINESCROLL:
4922 break;
4923
4924 case EM_SCROLLCARET:
4926 result = 1;
4927 break;
4928
4929 case EM_GETMODIFY:
4930 result = ((es->flags & EF_MODIFIED) != 0);
4931 break;
4932
4933 case EM_SETMODIFY:
4934 if (wParam)
4935 es->flags |= EF_MODIFIED;
4936 else
4937 es->flags &= ~(EF_MODIFIED | EF_UPDATE); /* reset pending updates */
4938 break;
4939
4940 case EM_GETLINECOUNT:
4941 result = (es->style & ES_MULTILINE) ? es->line_count : 1;
4942 break;
4943
4944 case EM_LINEINDEX:
4946 break;
4947
4948 case EM_SETHANDLE:
4950 break;
4951
4952 case EM_GETHANDLE:
4954 break;
4955
4956 case EM_GETTHUMB:
4958 break;
4959
4960 /* these messages missing from specs */
4961 case 0x00bf:
4962 case 0x00c0:
4963 case 0x00c3:
4964 case 0x00ca:
4965 FIXME("undocumented message 0x%x, please report\n", msg);
4967 break;
4968
4969 case EM_LINELENGTH:
4971 break;
4972
4973 case EM_REPLACESEL:
4974 {
4975 LPWSTR textW;
4976
4977 if(unicode)
4978 textW = (LPWSTR)lParam;
4979 else
4980 {
4982 INT countW = MultiByteToWideChar(CP_ACP, 0, textA, -1, NULL, 0);
4983 if (!(textW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR)))) break;
4984 MultiByteToWideChar(CP_ACP, 0, textA, -1, textW, countW);
4985 }
4986
4988 result = 1;
4989
4990 if(!unicode)
4992 break;
4993 }
4994
4995 case EM_GETLINE:
4997 break;
4998
4999 case EM_SETLIMITTEXT:
5001 break;
5002
5003 case EM_CANUNDO:
5005 break;
5006
5007 case EM_UNDO:
5008 case WM_UNDO:
5010 break;
5011
5012 case EM_FMTLINES:
5014 break;
5015
5016 case EM_LINEFROMCHAR:
5018 break;
5019
5020 case EM_SETTABSTOPS:
5022 break;
5023
5024 case EM_SETPASSWORDCHAR:
5025 {
5026 WCHAR charW = 0;
5027
5028 if(unicode)
5029 charW = (WCHAR)wParam;
5030 else
5031 {
5032 CHAR charA = wParam;
5033 MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
5034 }
5035
5037 break;
5038 }
5039
5040 case EM_EMPTYUNDOBUFFER:
5042 break;
5043
5045 result = (es->style & ES_MULTILINE) ? es->y_offset : es->x_offset;
5046 break;
5047
5048 case EM_SETREADONLY:
5049 {
5050 DWORD old_style = es->style;
5051
5052 if (wParam) {
5055 es->style |= ES_READONLY;
5056 } else {
5059 es->style &= ~ES_READONLY;
5060 }
5061
5062 if (old_style ^ es->style)
5063 InvalidateRect(es->hwndSelf, NULL, TRUE);
5064
5065 result = 1;
5066 break;
5067 }
5068
5071 break;
5072
5074 result = (LRESULT)es->word_break_proc;
5075 break;
5076
5077 case EM_GETPASSWORDCHAR:
5078 {
5079 if(unicode)
5080 result = es->password_char;
5081 else
5082 {
5083 WCHAR charW = es->password_char;
5084 CHAR charA = 0;
5085 WideCharToMultiByte(CP_ACP, 0, &charW, 1, &charA, 1, NULL, NULL);
5086 result = charA;
5087 }
5088 break;
5089 }
5090
5091 case EM_SETMARGINS:
5093 break;
5094
5095 case EM_GETMARGINS:
5096 result = MAKELONG(es->left_margin, es->right_margin);
5097 break;
5098
5099 case EM_GETLIMITTEXT:
5100 result = es->buffer_limit;
5101 break;
5102
5103 case EM_POSFROMCHAR:
5104 if ((INT)wParam >= get_text_length(es)) result = -1;
5106 break;
5107
5108 case EM_CHARFROMPOS:
5109 result = EDIT_EM_CharFromPos(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
5110 break;
5111
5112 /* End of the EM_ messages which were in numerical order; what order
5113 * are these in? vaguely alphabetical?
5114 */
5115
5116 case WM_NCCREATE:
5118 break;
5119
5120 case WM_NCDESTROY:
5122#ifdef __REACTOS__
5124#endif
5125 es = NULL;
5126 break;
5127
5128 case WM_GETDLGCODE:
5130
5131 if (es->style & ES_MULTILINE)
5133
5134 if (lParam)
5135 {
5136 es->flags|=EF_DIALOGMODE;
5137
5138 if (((LPMSG)lParam)->message == WM_KEYDOWN)
5139 {
5140 int vk = (int)((LPMSG)lParam)->wParam;
5141
5142 if (es->hwndListBox)
5143 {
5144 if (vk == VK_RETURN || vk == VK_ESCAPE)
5147 }
5148 }
5149 }
5150 break;
5151
5152 case WM_IME_CHAR:
5153#ifdef __REACTOS__
5154 /* Rely on DefWindowProc */
5155 result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
5156 break;
5157#else
5158 if (!unicode)
5159 {
5160 WCHAR charW;
5161 CHAR strng[2];
5162
5163 strng[0] = wParam >> 8;
5164 strng[1] = wParam & 0xff;
5165 if (strng[0]) MultiByteToWideChar(CP_ACP, 0, strng, 2, &charW, 1);
5166 else MultiByteToWideChar(CP_ACP, 0, &strng[1], 1, &charW, 1);
5167 result = EDIT_WM_Char(es, charW);
5168 break;
5169 }
5170 /* fall through */
5171#endif
5172 case WM_CHAR:
5173 {
5174 WCHAR charW;
5175
5176 if(unicode)
5177 charW = wParam;
5178 else
5179 {
5180 CHAR charA = wParam;
5181 MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
5182 }
5183
5184 if (es->hwndListBox)
5185 {
5186 if (charW == VK_RETURN || charW == VK_ESCAPE)
5187 {
5190 break;
5191 }
5192 }
5193 result = EDIT_WM_Char(es, charW);
5194 break;
5195 }
5196
5197 case WM_UNICHAR:
5198 if (unicode)
5199 {
5200 if (wParam == UNICODE_NOCHAR) return TRUE;
5201 if (wParam <= 0x000fffff)
5202 {
5203 if(wParam > 0xffff) /* convert to surrogates */
5204 {
5205 wParam -= 0x10000;
5206 EDIT_WM_Char(es, (wParam >> 10) + 0xd800);
5207 EDIT_WM_Char(es, (wParam & 0x03ff) + 0xdc00);
5208 }
5209 else EDIT_WM_Char(es, wParam);
5210 }
5211 return 0;
5212 }
5213 break;
5214
5215 case WM_CLEAR:
5217 break;
5218
5219 case WM_CONTEXTMENU:
5220 EDIT_WM_ContextMenu(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
5221 break;
5222
5223 case WM_COPY:
5225 break;
5226
5227 case WM_CREATE:
5228 if(unicode)
5230 else
5231 {
5232 LPCSTR nameA = ((LPCREATESTRUCTA)lParam)->lpszName;
5233 LPWSTR nameW = NULL;
5234 if(nameA)
5235 {
5236 INT countW = MultiByteToWideChar(CP_ACP, 0, nameA, -1, NULL, 0);
5237 if((nameW = HeapAlloc(GetProcessHeap(), 0, countW * sizeof(WCHAR))))
5238 MultiByteToWideChar(CP_ACP, 0, nameA, -1, nameW, countW);
5239 }
5242 }
5243 break;
5244
5245 case WM_CUT:
5246 EDIT_WM_Cut(es);
5247 break;
5248
5249 case WM_ENABLE:
5250 es->bEnableState = (BOOL) wParam;
5252 break;
5253
5254 case WM_ERASEBKGND:
5255 /* we do the proper erase in EDIT_WM_Paint */
5256 result = 1;
5257 break;
5258
5259 case WM_GETFONT:
5260 result = (LRESULT)es->font;
5261 break;
5262
5263 case WM_GETTEXT:
5265 break;
5266
5267 case WM_GETTEXTLENGTH:
5268 if (unicode) result = get_text_length(es);
5270 NULL, 0, NULL, NULL );
5271 break;
5272
5273 case WM_HSCROLL:
5275 break;
5276
5277 case WM_KEYDOWN:
5279 break;
5280
5281 case WM_KILLFOCUS:
5283 break;
5284
5285 case WM_LBUTTONDBLCLK:
5287 break;
5288
5289 case WM_LBUTTONDOWN:
5291 break;
5292
5293 case WM_LBUTTONUP:
5295 break;
5296
5297 case WM_MBUTTONDOWN:
5299 break;
5300
5301 case WM_MOUSEMOVE:
5302 result = EDIT_WM_MouseMove(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
5303 break;
5304
5305 case WM_PRINTCLIENT:
5306 case WM_PAINT:
5308 break;
5309
5310 case WM_PASTE:
5312 break;
5313
5314 case WM_SETFOCUS:
5316 break;
5317
5318 case WM_SETFONT:
5320 break;
5321
5322 case WM_SETREDRAW:
5323 /* FIXME: actually set an internal flag and behave accordingly */
5324 break;
5325
5326 case WM_SETTEXT:
5327 EDIT_WM_SetText(es, (LPCWSTR)lParam, unicode);
5328 result = TRUE;
5329 break;
5330
5331 case WM_SIZE:
5333 break;
5334
5335 case WM_STYLECHANGED:
5337 break;
5338
5339 case WM_STYLECHANGING:
5340 result = 0; /* See EDIT_WM_StyleChanged */
5341 break;
5342
5343 case WM_SYSKEYDOWN:
5345 break;
5346
5347 case WM_TIMER:
5349 break;
5350
5351 case WM_VSCROLL:
5353 break;
5354
5355 case WM_MOUSEWHEEL:
5356 {
5357 int wheelDelta;
5358 UINT pulScrollLines = 3;
5359 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
5360
5361 if (wParam & (MK_SHIFT | MK_CONTROL)) {
5363 break;
5364 }
5365 wheelDelta = GET_WHEEL_DELTA_WPARAM(wParam);
5366 /* if scrolling changes direction, ignore left overs */
5367 if ((wheelDelta < 0 && es->wheelDeltaRemainder < 0) ||
5368 (wheelDelta > 0 && es->wheelDeltaRemainder > 0))
5369 es->wheelDeltaRemainder += wheelDelta;
5370 else
5371 es->wheelDeltaRemainder = wheelDelta;
5372 if (es->wheelDeltaRemainder && pulScrollLines)
5373 {
5374 int cLineScroll;
5375 pulScrollLines = (int) min((UINT) es->line_count, pulScrollLines);
5376 cLineScroll = pulScrollLines * (float)es->wheelDeltaRemainder / WHEEL_DELTA;
5377 es->wheelDeltaRemainder -= WHEEL_DELTA * cLineScroll / (int)pulScrollLines;
5378 result = EDIT_EM_LineScroll(es, 0, -cLineScroll);
5379 }
5380 }
5381 break;
5382
5383
5384 /* IME messages to make the edit control IME aware */
5385 case WM_IME_SETCONTEXT:
5386#ifdef __REACTOS__
5387 if (FALSE) /* FIXME: Condition */
5388 lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
5389
5390 if (wParam)
5391 {
5392 HIMC hIMC = ImmGetContext(hwnd);
5394 if (pIC)
5395 {
5396 pIC->dwUIFlags &= ~0x40000;
5397 ImmUnlockIMC(hIMC);
5398 }
5399 if (GetWin32ClientInfo()->CI_flags & CI_WOW)
5401 ImmReleaseContext(hwnd, hIMC);
5402 }
5403
5405#endif
5406 break;
5407
5408 case WM_IME_STARTCOMPOSITION:
5409#ifdef __REACTOS__
5410 if (FALSE) /* FIXME: Condition */
5411 return TRUE;
5412 result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
5413#else
5414 es->composition_start = es->selection_end;
5415 es->composition_len = 0;
5416#endif
5417 break;
5418
5419 case WM_IME_COMPOSITION:
5421#ifdef __REACTOS__
5422 result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
5423#endif
5424 break;
5425
5426 case WM_IME_ENDCOMPOSITION:
5427#ifdef __REACTOS__
5428 result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
5429#else
5430 if (es->composition_len > 0)
5431 {
5433 es->selection_end = es->selection_start;
5434 es->composition_len= 0;
5435 }
5436#endif
5437 break;
5438
5440 break;
5441
5442 case WM_IME_SELECT:
5443#ifdef __REACTOS__
5444 result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
5445#endif
5446 break;
5447
5448 case WM_IME_CONTROL:
5449#ifdef __REACTOS__
5450 result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
5451#endif
5452 break;
5453
5454 case WM_IME_REQUEST:
5455 switch (wParam)
5456 {
5457 case IMR_QUERYCHARPOSITION:
5458 {
5459 LRESULT pos;
5460 IMECHARPOSITION *chpos = (IMECHARPOSITION *)lParam;
5461
5462 pos = EDIT_EM_PosFromChar(es, es->selection_start + chpos->dwCharPos, FALSE);
5463 chpos->pt.x = LOWORD(pos);
5464 chpos->pt.y = HIWORD(pos);
5465 chpos->cLineHeight = es->line_height;
5466 chpos->rcDocument = es->format_rect;
5467 MapWindowPoints(hwnd, 0, &chpos->pt, 1);
5468 MapWindowPoints(hwnd, 0, (POINT*)&chpos->rcDocument, 2);
5469 result = 1;
5470 break;
5471 }
5472 }
5473 break;
5474
5475 default:
5476 result = DefWindowProcT(hwnd, msg, wParam, lParam, unicode);
5477 break;
5478 }
5479
5480#ifdef __REACTOS__
5481 /* ReactOS: check GetWindowLong in case es has been destroyed during processing */
5482 if (IsWindow(hwnd) && es && msg != EM_GETHANDLE && GetWindowLongPtrW(hwnd, 0))
5483#else
5484 if (IsWindow(hwnd) && es && msg != EM_GETHANDLE)
5485#endif
5487
5488 TRACE("hwnd=%p msg=%x (%s) -- 0x%08lx\n", hwnd, msg, SPY_GetMsgName(msg, hwnd), result);
5489
5490 return result;
static const WCHAR nameW[]
Definition: main.c:49
static LRESULT EDIT_WM_LButtonDblClk(EDITSTATE *es)
Definition: edit.c:3505
static LRESULT EDIT_WM_Char(EDITSTATE *es, WCHAR c)
Definition: edit.c:3080
static LRESULT EDIT_WM_MButtonDown(EDITSTATE *es)
Definition: edit.c:3576
static BOOL EDIT_EM_FmtLines(EDITSTATE *es, BOOL add_eol)
Definition: edit.c:2391
static LRESULT EDIT_EM_CharFromPos(EDITSTATE *es, INT x, INT y)
Definition: edit.c:2363
static void EDIT_EM_SetPasswordChar(EDITSTATE *es, WCHAR c)
Definition: edit.c:2866
static INT EDIT_WM_GetText(const EDITSTATE *es, INT count, LPWSTR dst)
Definition: edit.c:3267
static void EDIT_WM_ContextMenu(EDITSTATE *es, INT x, INT y)
Definition: edit.c:3211
static LRESULT EDIT_WM_MouseMove(EDITSTATE *es, INT x, INT y)
Definition: edit.c:3588
static LRESULT EDIT_WM_NCDestroy(EDITSTATE *es)
Definition: edit.c:4687
static LRESULT EDIT_WM_LButtonDown(EDITSTATE *es, DWORD keys, INT x, INT y)
Definition: edit.c:3534
static HLOCAL EDIT_EM_GetHandle(EDITSTATE *es)
Definition: edit.c:2413
static INT EDIT_EM_GetLine(EDITSTATE *es, INT line, LPWSTR dst)
Definition: edit.c:2433
static LRESULT EDIT_WM_KillFocus(HTHEME theme, EDITSTATE *es)
Definition: edit.c:3477
static LRESULT EDIT_WM_SysKeyDown(EDITSTATE *es, INT key, DWORD key_data)
Definition: edit.c:4017
static LRESULT EDIT_EM_GetThumb(EDITSTATE *es)
Definition: edit.c:4306
static LRESULT EDIT_WM_NCCreate(HWND hwnd, LPCREATESTRUCTW lpcs)
Definition: edit.c:4519
static LRESULT EDIT_WM_LButtonUp(EDITSTATE *es)
Definition: edit.c:3560
static void EDIT_WM_SetFocus(HTHEME theme, EDITSTATE *es)
Definition: edit.c:3771
static void EDIT_EM_SetHandle(EDITSTATE *es, HLOCAL hloc)
Definition: edit.c:2705
static LRESULT EDIT_WM_Create(EDITSTATE *es, const WCHAR *name)
Definition: edit.c:4632
static LRESULT EDIT_WM_KeyDown(EDITSTATE *es, INT key)
Definition: edit.c:3343
static void EDIT_EM_SetLimitText(EDITSTATE *es, UINT limit)
Definition: edit.c:2744
static void EDIT_WM_Timer(EDITSTATE *es)
Definition: edit.c:4036
static LRESULT EDIT_EM_GetSel(const EDITSTATE *es, PUINT start, PUINT end)
Definition: edit.c:2471
static void EDIT_EM_SetWordBreakProc(EDITSTATE *es, EDITWORDBREAKPROCW wbp)
Definition: edit.c:2917
static LRESULT EDIT_WM_StyleChanged(EDITSTATE *es, WPARAM which, const STYLESTRUCT *style)
Definition: edit.c:3977
static void EDIT_WM_SetText(EDITSTATE *es, LPCWSTR text)
Definition: edit.c:3902
static BOOL EDIT_EM_SetTabStops(EDITSTATE *es, INT count, const INT *tabs)
Definition: edit.c:2895
static void EDIT_ImeComposition(HWND hwnd, LPARAM CompFlag, EDITSTATE *es)
Definition: edit.c:4473
static void EDIT_WM_Size(EDITSTATE *es, UINT action)
Definition: edit.c:3944
BOOL WINAPI ImmNotifyIME(HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD_PTR dwValue)
Definition: ime.c:907
BOOL WINAPI ImmUnlockIMC(HIMC hIMC)
Definition: imm.c:1067
LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC hIMC)
Definition: imm.c:1058
#define ValidateHwnd(hwnd)
Definition: precomp.h:85
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
GLuint64EXT * result
Definition: glext.h:11304
struct INPUTCONTEXTDX * LPINPUTCONTEXTDX
#define CPS_CANCEL
Definition: imm.h:181
#define NI_COMPOSITIONSTR
Definition: immdev.h:403
#define FNID_DESTROY
Definition: ntuser.h:898
#define FNID_EDIT
Definition: ntuser.h:870
#define GetWin32ClientInfo()
Definition: ntuser.h:352
#define CI_WOW
Definition: ntuser.h:302
BOOL NTAPI NtUserSetWindowFNID(HWND hWnd, WORD fnID)
Definition: window.c:4335
WORD vk
Definition: input.c:77
unsigned int * PUINT
Definition: ndis.h:50
#define LRESULT
Definition: ole.h:14
#define EM_SCROLLCARET
Definition: richedit.h:81
#define WM_UNICHAR
Definition: richedit.h:67
#define EM_POSFROMCHAR
Definition: richedit.h:77
#define WM_CONTEXTMENU
Definition: richedit.h:64
#define EM_CHARFROMPOS
Definition: richedit.h:78
#define WM_PRINTCLIENT
Definition: richedit.h:70
#define EM_GETLIMITTEXT
Definition: richedit.h:74
Definition: ntuser.h:694
DWORD fnid
Definition: ntuser.h:709
Definition: tftpd.h:60
#define WHEEL_DELTA
Definition: treelist.c:99
#define WM_MOUSEWHEEL
Definition: treelist.c:96
const char * SPY_GetMsgName(UINT msg, HWND hWnd)
Definition: spy.c:2218
static LRESULT DefWindowProcT(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode)
Definition: edit.c:4839
int * LPINT
Definition: windef.h:178
#define WM_PAINT
Definition: winuser.h:1623
#define EM_SETREADONLY
Definition: winuser.h:2018
#define WM_ERASEBKGND
Definition: winuser.h:1628
#define WM_GETTEXTLENGTH
Definition: winuser.h:1622
#define EM_GETRECT
Definition: winuser.h:1999
#define WM_IME_REQUEST
Definition: winuser.h:1839
#define EM_LINEFROMCHAR
Definition: winuser.h:2004
#define WM_ENABLE
Definition: winuser.h:1618
#define WM_HSCROLL
Definition: winuser.h:1746
#define EM_GETWORDBREAKPROC
Definition: winuser.h:2002
#define EM_FMTLINES
Definition: winuser.h:1989
#define EM_GETPASSWORDCHAR
Definition: winuser.h:1998
#define WM_VSCROLL
Definition: winuser.h:1747
#define WM_CREATE
Definition: winuser.h:1611
#define DLGC_WANTCHARS
Definition: winuser.h:2621
#define EM_GETSEL
Definition: winuser.h:2000
#define EM_SETPASSWORDCHAR
Definition: winuser.h:2017
#define EM_GETMODIFY
Definition: winuser.h:1997
#define WM_SIZE
Definition: winuser.h:1614
#define EM_EMPTYUNDOBUFFER
Definition: winuser.h:1988
#define DLGC_WANTALLKEYS
Definition: winuser.h:2615
#define WM_LBUTTONDBLCLK
Definition: winuser.h:1781
#define EM_REPLACESEL
Definition: winuser.h:2009
struct tagCREATESTRUCTA * LPCREATESTRUCTA
#define EM_SETRECT
Definition: winuser.h:2019
#define WM_SETFOCUS
Definition: winuser.h:1616
#define WM_MOUSEMOVE
Definition: winuser.h:1778
#define WM_GETTEXT
Definition: winuser.h:1621
#define WM_LBUTTONDOWN
Definition: winuser.h:1779
#define EM_LINEINDEX
Definition: winuser.h:2005
#define WM_GETFONT
Definition: winuser.h:1654
#define EM_GETFIRSTVISIBLELINE
Definition: winuser.h:1991
#define EM_GETHANDLE
Definition: winuser.h:1992
#define WM_NCCREATE
Definition: winuser.h:1686
#define WM_IME_SETCONTEXT
Definition: winuser.h:1832
#define WM_SETTEXT
Definition: winuser.h:1620
#define EM_CANUNDO
Definition: winuser.h:1986
#define EM_LINELENGTH
Definition: winuser.h:2006
#define WM_IME_CHAR
Definition: winuser.h:1837
#define EM_SETHANDLE
Definition: winuser.h:2012
#define EM_GETLINE
Definition: winuser.h:1994
#define EM_SETRECTNP
Definition: winuser.h:2020
#define MK_CONTROL
Definition: winuser.h:2373
#define EM_SETLIMITTEXT
Definition: winuser.h:2014
#define WM_SETFONT
Definition: winuser.h:1653
#define WM_TIMER
Definition: winuser.h:1745
#define DLGC_WANTARROWS
Definition: winuser.h:2613
#define EM_SCROLL
Definition: winuser.h:2010
#define EM_SETWORDBREAKPROC
Definition: winuser.h:2023
#define WM_LBUTTONUP
Definition: winuser.h:1780
BOOL WINAPI SystemParametersInfoW(_In_ UINT uiAction, _In_ UINT uiParam, _Inout_opt_ PVOID pvParam, _In_ UINT fWinIni)
#define WM_IME_COMPOSITIONFULL
Definition: winuser.h:1835
#define WM_CHAR
Definition: winuser.h:1720
#define WM_NCDESTROY
Definition: winuser.h:1687
#define EM_GETMARGINS
Definition: winuser.h:1996
#define WM_IME_CONTROL
Definition: winuser.h:1834
#define EM_SETTABSTOPS
Definition: winuser.h:2022
#define DLGC_WANTMESSAGE
Definition: winuser.h:2616
#define WM_IME_SELECT
Definition: winuser.h:1836
#define EM_GETLINECOUNT
Definition: winuser.h:1995
#define EM_SETMARGINS
Definition: winuser.h:2015
#define DLGC_HASSETSEL
Definition: winuser.h:2617
#define WM_KILLFOCUS
Definition: winuser.h:1617
#define WM_GETDLGCODE
Definition: winuser.h:1692
#define WM_MBUTTONDOWN
Definition: winuser.h:1785
#define EM_SETMODIFY
Definition: winuser.h:2016
#define WM_SETREDRAW
Definition: winuser.h:1619
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by RegisterClientPFN().

◆ get_app_version()

static DWORD get_app_version ( void  )
static

Definition at line 223 of file edit.c.

225{
226 static DWORD version;
227 if (!version)
228 {
229 DWORD dwEmulatedVersion;
231 DWORD dwProcVersion = GetProcessVersion(0);
232
233 info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
235 dwEmulatedVersion = MAKELONG( info.dwMinorVersion, info.dwMajorVersion );
236 /* FIXME: this may not be 100% correct; see discussion on the
237 * wine developer list in Nov 1999 */
238 version = dwProcVersion < dwEmulatedVersion ? dwProcVersion : dwEmulatedVersion;
239 }
240 return version;
static const WCHAR version[]
Definition: asmname.c:66
DWORD WINAPI GetProcessVersion(IN DWORD ProcessId)
Definition: proc.c:1766
BOOL WINAPI GetVersionExW(IN LPOSVERSIONINFOW lpVersionInformation)
Definition: version.c:37
struct _OSVERSIONINFOW OSVERSIONINFOW

Referenced by EDIT_NotifyCtlColor().

◆ get_text_length()

static UINT get_text_length ( EDITSTATE es)
inlinestatic

Definition at line 265 of file edit.c.

267{
268 if(es->text_length == (UINT)-1)
269 es->text_length = strlenW(es->text);
270 return es->text_length;

◆ get_vertical_line_count()

static INT get_vertical_line_count ( EDITSTATE es)
inlinestatic

Definition at line 505 of file edit.c.

507{
508 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
509 return max(1,vlc);

◆ is_cjk()

static BOOL is_cjk ( UINT  charset)
static

Definition at line 2987 of file edit.c.

2989{
2990 switch(charset)
2991 {
2992 case SHIFTJIS_CHARSET:
2993 case HANGUL_CHARSET:
2994 case GB2312_CHARSET:
2996 return TRUE;
2997 }
2998 /* HANGUL_CHARSET is strange, though treated as CJK by Win 8, it is
2999 * not by other versions including Win 10. */
3000 return FALSE;
CFF_Charset charset
Definition: cffcmap.c:138
#define HANGUL_CHARSET
Definition: wingdi.h:388
#define CHINESEBIG5_CHARSET
Definition: wingdi.h:390
#define SHIFTJIS_CHARSET
Definition: wingdi.h:386
#define GB2312_CHARSET
Definition: wingdi.h:389

◆ notify_parent()

static BOOL notify_parent ( const EDITSTATE es,
INT  code 
)
inlinestatic

Definition at line 174 of file edit.c.

174 {0};
175static inline BOOL notify_parent(const EDITSTATE *es, INT code)
176{
177 HWND hwnd = es->hwndSelf;
178 TRACE("notification %d sent to %p.\n", code, es->hwndParent);
179 SendMessageW(es->hwndParent, WM_COMMAND, MAKEWPARAM(GetWindowLongPtrW(es->hwndSelf, GWLP_ID), code), (LPARAM)es->hwndSelf);
180 return IsWindow(hwnd);
Definition: inflate.c:139
#define MAKEWPARAM(l, h)
Definition: winuser.h:4012
#define WM_COMMAND
Definition: winuser.h:1743
#define GWLP_ID
Definition: winuser.h:863

◆ text_buffer_changed()

static void text_buffer_changed ( EDITSTATE es)
inlinestatic

Definition at line 1290 of file edit.c.

1292{
1293 es->text_length = (UINT)-1;
1294
1295 HeapFree( GetProcessHeap(), 0, es->logAttr );
1296 es->logAttr = NULL;

◆ WINE_DECLARE_DEBUG_CHANNEL() [1/2]

WINE_DECLARE_DEBUG_CHANNEL ( combo  )

◆ WINE_DECLARE_DEBUG_CHANNEL() [2/2]

WINE_DECLARE_DEBUG_CHANNEL ( relay  )

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( edit  )

Variable Documentation

◆ EDIT_builtin_class

const struct builtin_class_descr EDIT_builtin_class
Initial value:
=
{
WINPROC_EDIT,
sizeof(EDITSTATE *) + sizeof(WORD),
0
}
static const WCHAR editW[]
Definition: edit.c:5517
#define CS_DBLCLKS
Definition: winuser.h:651
#define IDC_IBEAM
Definition: winuser.h:688
#define CS_PARENTDC
Definition: winuser.h:656

Definition at line 5518 of file edit.c.

◆ editW

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

Definition at line 5517 of file edit.c.

Referenced by create_editcontrolW().

◆ empty_stringW