ReactOS 0.4.16-dev-297-gc569aee
edit.c File Reference
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "imm.h"
#include "usp10.h"
#include "commctrl.h"
#include "uxtheme.h"
#include "vsstyle.h"
#include "wine/debug.h"
#include "wine/heap.h"
Include dependency graph for edit.c:

Go to the source code of this file.

Classes

struct  tagLINEDEF
 
struct  EDITSTATE
 
struct  char_width_info
 

Macros

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

Typedefs

typedef struct tagLINEDEF LINEDEF
 

Enumerations

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

Functions

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

Macro Definition Documentation

◆ BUFLIMIT_INITIAL

#define BUFLIMIT_INITIAL   30000 /* initial buffer size */

Definition at line 57 of file edit.c.

◆ EF_AFTER_WRAP

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

Definition at line 70 of file edit.c.

◆ EF_DIALOGMODE

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

Definition at line 72 of file edit.c.

◆ EF_FOCUSED

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

Definition at line 66 of file edit.c.

◆ EF_HSCROLL_TRACK

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

Definition at line 69 of file edit.c.

◆ EF_MODIFIED

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

Definition at line 65 of file edit.c.

◆ EF_UPDATE

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

Definition at line 67 of file edit.c.

◆ EF_USE_SOFTBRK

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

Definition at line 71 of file edit.c.

◆ EF_VSCROLL_TRACK

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

Definition at line 68 of file edit.c.

◆ GROWLENGTH

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

Definition at line 58 of file edit.c.

◆ HSCROLL_FRACTION

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

Definition at line 60 of file edit.c.

◆ ID_CB_LISTBOX

#define ID_CB_LISTBOX   1000

Definition at line 74 of file edit.c.

◆ ORDER_UINT

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

Definition at line 164 of file edit.c.

◆ ROUND_TO_GROW

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

Definition at line 59 of file edit.c.

◆ SWAP_UINT32

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

Definition at line 163 of file edit.c.

Typedef Documentation

◆ LINEDEF

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

78{
79 END_0 = 0, /* line ends with terminating '\0' character */
80 END_WRAP, /* line is wrapped */
81 END_HARD, /* line ends with a hard return '\r\n' */
82 END_SOFT, /* line ends with a soft return '\r\r\n' */
83 END_RICH /* line ends with a single '\n' */
@ END_SOFT
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

◆ EDIT_AdjustFormatRect()

static void EDIT_AdjustFormatRect ( EDITSTATE es)
static

Definition at line 2268 of file edit.c.

2270{
2271 RECT ClientRect;
2272
2273 es->format_rect.right = max(es->format_rect.right, es->format_rect.left + es->char_width);
2274 if (es->style & ES_MULTILINE)
2275 {
2276 INT fw, vlc, max_x_offset, max_y_offset;
2277
2279 es->format_rect.bottom = es->format_rect.top + vlc * es->line_height;
2280
2281 /* correct es->x_offset */
2282 fw = es->format_rect.right - es->format_rect.left;
2283 max_x_offset = es->text_width - fw;
2284 if(max_x_offset < 0) max_x_offset = 0;
2285 if(es->x_offset > max_x_offset)
2286 es->x_offset = max_x_offset;
2287
2288 /* correct es->y_offset */
2289 max_y_offset = es->line_count - vlc;
2290 if(max_y_offset < 0) max_y_offset = 0;
2291 if(es->y_offset > max_y_offset)
2292 es->y_offset = max_y_offset;
2293
2294 /* force scroll info update */
2296 }
2297 else
2298 /* Windows doesn't care to fix text placement for SL controls */
2299 es->format_rect.bottom = es->format_rect.top + es->line_height;
2300
2301 /* Always stay within the client area */
2302 GetClientRect(es->hwndSelf, &ClientRect);
2303 es->format_rect.bottom = min(es->format_rect.bottom, ClientRect.bottom);
2304
2305 if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL))
2307
2308 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)

Referenced by EDIT_EM_SetMargins(), and EDIT_SetRectNP().

◆ EDIT_BuildLineDefs_ML()

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

Definition at line 429 of file edit.c.

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

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

◆ EDIT_CalcLineWidth_SL()

static void EDIT_CalcLineWidth_SL ( EDITSTATE es)
static

Definition at line 761 of file edit.c.

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

Referenced by EDIT_EM_ReplaceSel(), and EDIT_WM_SetFont().

◆ EDIT_CallWordBreakProc()

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

Definition at line 294 of file edit.c.

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

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

◆ EDIT_CharFromPos()

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

Definition at line 784 of file edit.c.

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

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

◆ EDIT_CheckCombo()

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

Definition at line 3281 of file edit.c.

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

Referenced by EDIT_WM_KeyDown(), and EDIT_WM_SysKeyDown().

◆ EDIT_ConfinePoint()

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

Definition at line 901 of file edit.c.

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

Referenced by EDIT_WM_LButtonDown(), and EDIT_WM_MouseMove().

◆ EDIT_ContextMenuCommand()

static void EDIT_ContextMenuCommand ( EDITSTATE es,
UINT  id 
)
static

Definition at line 3167 of file edit.c.

3169{
3170 switch (id) {
3171 case EM_UNDO:
3172 SendMessageW(es->hwndSelf, WM_UNDO, 0, 0);
3173 break;
3174 case WM_CUT:
3175 SendMessageW(es->hwndSelf, WM_CUT, 0, 0);
3176 break;
3177 case WM_COPY:
3178 SendMessageW(es->hwndSelf, WM_COPY, 0, 0);
3179 break;
3180 case WM_PASTE:
3181 SendMessageW(es->hwndSelf, WM_PASTE, 0, 0);
3182 break;
3183 case WM_CLEAR:
3184 SendMessageW(es->hwndSelf, WM_CLEAR, 0, 0);
3185 break;
3186 case EM_SETSEL:
3187 SendMessageW(es->hwndSelf, EM_SETSEL, 0, -1);
3188 break;
3189 default:
3190 ERR("unknown menu item, please report\n");
3191 break;
3192 }
#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

Referenced by EDIT_WM_ContextMenu().

◆ EDIT_EM_CanUndo()

static BOOL EDIT_EM_CanUndo ( const EDITSTATE es)
inlinestatic

Definition at line 181 of file edit.c.

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

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

◆ EDIT_EM_CharFromPos()

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

Definition at line 2363 of file edit.c.

2365{
2366 POINT pt;
2367 RECT rc;
2368 INT index;
2369
2370 pt.x = x;
2371 pt.y = y;
2372 GetClientRect(es->hwndSelf, &rc);
2373 if (!PtInRect(&rc, pt))
2374 return -1;
2375
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)

Referenced by EDIT_WindowProc().

◆ EDIT_EM_EmptyUndoBuffer()

static void EDIT_EM_EmptyUndoBuffer ( EDITSTATE es)
inlinestatic

Definition at line 192 of file edit.c.

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

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

◆ EDIT_EM_FmtLines()

static BOOL EDIT_EM_FmtLines ( EDITSTATE es,
BOOL  add_eol 
)
static

Definition at line 2391 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetCueBanner()

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

Definition at line 4342 of file edit.c.

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

Referenced by EDIT_WindowProc().

◆ EDIT_EM_GetHandle()

static HLOCAL EDIT_EM_GetHandle ( EDITSTATE es)
static

Definition at line 2413 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetLine()

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

Definition at line 2433 of file edit.c.

2435{
2436 INT line_len, dst_len;
2437 LPWSTR src;
2438 INT i;
2439
2440 if (es->style & ES_MULTILINE)
2441 {
2442 if (line >= es->line_count)
2443 return 0;
2444 }
2445 else
2446 line = 0;
2447
2449 src = es->text + i;
2450 line_len = EDIT_EM_LineLength(es, i);
2451 dst_len = *(WORD *)dst;
2452
2453 if (dst_len <= line_len)
2454 {
2455 memcpy(dst, src, dst_len * sizeof(WCHAR));
2456 return dst_len;
2457 }
2458 else /* Append 0 if enough space */
2459 {
2460 memcpy(dst, src, line_len * sizeof(WCHAR));
2461 dst[line_len] = 0;
2462 return line_len;
2463 }
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
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetSel()

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

Definition at line 2471 of file edit.c.

2473{
2474 UINT s = es->selection_start;
2475 UINT e = es->selection_end;
2476
2477 ORDER_UINT(s, e);
2478 if (start)
2479 *start = s;
2480 if (end)
2481 *end = e;
2482 return MAKELONG(s, e);
#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
unsigned int UINT
Definition: ndis.h:50

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetThumb()

static LRESULT EDIT_EM_GetThumb ( EDITSTATE es)
static

Definition at line 4306 of file edit.c.

4308{
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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_LineFromChar()

static INT EDIT_EM_LineFromChar ( EDITSTATE es,
INT  index 
)
static

Definition at line 913 of file edit.c.

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

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

◆ EDIT_EM_LineIndex()

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

Definition at line 942 of file edit.c.

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

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

◆ EDIT_EM_LineLength()

static INT EDIT_EM_LineLength ( EDITSTATE es,
INT  index 
)
static

Definition at line 977 of file edit.c.

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

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

◆ EDIT_EM_LineScroll()

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

Definition at line 1657 of file edit.c.

1659{
1660 if (!(es->style & ES_MULTILINE))
1661 return FALSE;
1662
1663 dx *= es->char_width;
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

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

◆ EDIT_EM_LineScroll_internal()

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

Definition at line 1601 of file edit.c.

1603{
1604 INT nyoff;
1605 INT x_offset_in_pixels;
1606 INT lines_per_page = (es->format_rect.bottom - es->format_rect.top) /
1607 es->line_height;
1608
1609 if (es->style & ES_MULTILINE)
1610 {
1611 x_offset_in_pixels = es->x_offset;
1612 }
1613 else
1614 {
1615 dy = 0;
1616 x_offset_in_pixels = (short)LOWORD(EDIT_EM_PosFromChar(es, es->x_offset, FALSE));
1617 }
1618
1619 if (-dx > x_offset_in_pixels)
1620 dx = -x_offset_in_pixels;
1621 if (dx > es->text_width - x_offset_in_pixels)
1622 dx = es->text_width - x_offset_in_pixels;
1623 nyoff = max(0, es->y_offset + dy);
1624 if (nyoff >= es->line_count - lines_per_page)
1625 nyoff = max(0, es->line_count - lines_per_page);
1626 dy = (es->y_offset - nyoff) * es->line_height;
1627 if (dx || dy) {
1628 RECT rc1;
1629 RECT rc;
1630
1631 es->y_offset = nyoff;
1632 if(es->style & ES_MULTILINE)
1633 es->x_offset += dx;
1634 else
1635 es->x_offset += dx / es->char_width;
1636
1637 GetClientRect(es->hwndSelf, &rc1);
1638 IntersectRect(&rc, &rc1, &es->format_rect);
1639 ScrollWindowEx(es->hwndSelf, -dx, dy,
1640 NULL, &rc, NULL, NULL, SW_INVALIDATE);
1641 /* force scroll info update */
1643 }
1644 if (dx && !(es->flags & EF_HSCROLL_TRACK))
1646 if (dy && !(es->flags & EF_VSCROLL_TRACK))
1648 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)

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

◆ EDIT_EM_PosFromChar()

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

Definition at line 1013 of file edit.c.

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

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

◆ EDIT_EM_ReplaceSel()

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

Definition at line 2492 of file edit.c.

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

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

◆ EDIT_EM_Scroll()

static LRESULT EDIT_EM_Scroll ( EDITSTATE es,
INT  action 
)
static

Definition at line 1672 of file edit.c.

1674{
1675 INT dy;
1676
1677 if (!(es->style & ES_MULTILINE))
1678 return (LRESULT)FALSE;
1679
1680 dy = 0;
1681
1682 switch (action) {
1683 case SB_LINEUP:
1684 if (es->y_offset)
1685 dy = -1;
1686 break;
1687 case SB_LINEDOWN:
1688 if (es->y_offset < es->line_count - 1)
1689 dy = 1;
1690 break;
1691 case SB_PAGEUP:
1692 if (es->y_offset)
1693 dy = -(es->format_rect.bottom - es->format_rect.top) / es->line_height;
1694 break;
1695 case SB_PAGEDOWN:
1696 if (es->y_offset < es->line_count - 1)
1697 dy = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
1698 break;
1699 default:
1701 }
1702 if (dy) {
1704 /* check if we are going to move too far */
1705 if(es->y_offset + dy > es->line_count - vlc)
1706 dy = max(es->line_count - vlc, 0) - es->y_offset;
1707
1708 /* Notification is done in EDIT_EM_LineScroll */
1709 if(dy) {
1711 return MAKELONG(dy, TRUE);
1712 }
1713
1714 }
1715 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

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

◆ EDIT_EM_ScrollCaret()

static void EDIT_EM_ScrollCaret ( EDITSTATE es)
static

Definition at line 1780 of file edit.c.

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

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

◆ EDIT_EM_SetCueBanner()

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

Definition at line 4325 of file edit.c.

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

Referenced by EDIT_WindowProc().

◆ EDIT_EM_SetHandle()

static void EDIT_EM_SetHandle ( EDITSTATE es,
HLOCAL  hloc 
)
static

Definition at line 2705 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetLimitText()

static void EDIT_EM_SetLimitText ( EDITSTATE es,
UINT  limit 
)
static

Definition at line 2744 of file edit.c.

2746{
2747 if (!limit) limit = ~0u;
2748 if (!(es->style & ES_MULTILINE)) limit = min(limit, 0x7ffffffe);
2749 es->buffer_limit = limit;
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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetMargins()

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

Definition at line 2794 of file edit.c.

2797{
2799 INT default_left_margin = 0; /* in pixels */
2800 INT default_right_margin = 0; /* in pixels */
2801
2802 /* Set the default margins depending on the font */
2803 if (es->font && (left == EC_USEFONTINFO || right == EC_USEFONTINFO)) {
2804 HDC dc = GetDC(es->hwndSelf);
2805 HFONT old_font = SelectObject(dc, es->font);
2806 LONG width = GdiGetCharDimensions(dc, &tm, NULL), rc_width;
2807 RECT rc;
2808
2809 /* The default margins are only non zero for TrueType or Vector fonts */
2810 if (tm.tmPitchAndFamily & ( TMPF_VECTOR | TMPF_TRUETYPE )) {
2811 struct char_width_info width_info;
2812
2813 if (is_cjk(dc) && GetCharWidthInfo(dc, &width_info))
2814 {
2815 default_left_margin = get_cjk_fontinfo_margin(width, width_info.min_lsb);
2816 default_right_margin = get_cjk_fontinfo_margin(width, width_info.min_rsb);
2817 }
2818 else
2819 {
2820 default_left_margin = width / 2;
2821 default_right_margin = width / 2;
2822 }
2823
2824 GetClientRect(es->hwndSelf, &rc);
2825 rc_width = !IsRectEmpty(&rc) ? rc.right - rc.left : 80;
2826 if (rc_width < default_left_margin + default_right_margin + width * 2) {
2827 default_left_margin = es->left_margin;
2828 default_right_margin = es->right_margin;
2829 }
2830 }
2831 SelectObject(dc, old_font);
2832 ReleaseDC(es->hwndSelf, dc);
2833 }
2834
2835 if (action & EC_LEFTMARGIN) {
2836 es->format_rect.left -= es->left_margin;
2837 if (left != EC_USEFONTINFO)
2838 es->left_margin = left;
2839 else
2840 es->left_margin = default_left_margin;
2841 es->format_rect.left += es->left_margin;
2842 }
2843
2844 if (action & EC_RIGHTMARGIN) {
2845 es->format_rect.right += es->right_margin;
2846 if (right != EC_USEFONTINFO)
2847 es->right_margin = right;
2848 else
2849 es->right_margin = default_right_margin;
2850 es->format_rect.right -= es->right_margin;
2851 }
2852
2855 if (repaint) EDIT_UpdateText(es, NULL, TRUE);
2856 }
2857
2858 TRACE("left=%d, right=%d\n", es->left_margin, es->right_margin);
BOOL WINAPI GetCharWidthInfo(HDC, struct char_width_info *)
static void EDIT_AdjustFormatRect(EDITSTATE *es)
Definition: edit.c:2268
static int get_cjk_fontinfo_margin(int width, int side_bearing)
Definition: edit.c:2765
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

Referenced by EDIT_WindowProc(), and EDIT_WM_SetFont().

◆ EDIT_EM_SetPasswordChar()

static void EDIT_EM_SetPasswordChar ( EDITSTATE es,
WCHAR  c 
)
static

Definition at line 2866 of file edit.c.

2868{
2869 LONG style;
2870
2871 if (es->style & ES_MULTILINE)
2872 return;
2873
2874 if (es->password_char == c)
2875 return;
2876
2877 style = GetWindowLongW( es->hwndSelf, GWL_STYLE );
2878 es->password_char = c;
2879 if (c) {
2880 SetWindowLongW( es->hwndSelf, GWL_STYLE, style | ES_PASSWORD );
2881 es->style |= ES_PASSWORD;
2882 } else {
2883 SetWindowLongW( es->hwndSelf, GWL_STYLE, style & ~ES_PASSWORD );
2884 es->style &= ~ES_PASSWORD;
2885 }
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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetSel()

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

Definition at line 1489 of file edit.c.

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

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

◆ EDIT_EM_SetTabStops()

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

Definition at line 2895 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetWordBreakProc()

static void EDIT_EM_SetWordBreakProc ( EDITSTATE es,
EDITWORDBREAKPROCW  wbp 
)
static

Definition at line 2917 of file edit.c.

2919{
2920 if (es->word_break_proc == wbp)
2921 return;
2922
2923 es->word_break_proc = wbp;
2924
2925 if ((es->style & ES_MULTILINE) && !(es->style & ES_AUTOHSCROLL)) {
2928 }

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_Undo()

static BOOL EDIT_EM_Undo ( EDITSTATE es)
static

Definition at line 2936 of file edit.c.

2938{
2939 INT ulength;
2940 LPWSTR utext;
2941
2942 /* As per MSDN spec, for a single-line edit control,
2943 the return value is always TRUE */
2944 if( es->style & ES_READONLY )
2945 return !(es->style & ES_MULTILINE);
2946
2947 ulength = lstrlenW(es->undo_text);
2948
2949 utext = heap_alloc((ulength + 1) * sizeof(WCHAR));
2950
2951 lstrcpyW(utext, es->undo_text);
2952
2953 TRACE("before UNDO:insertion length = %d, deletion buffer = %s\n",
2954 es->undo_insert_count, debugstr_w(utext));
2955
2956 EDIT_EM_SetSel(es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
2958 EDIT_EM_ReplaceSel(es, TRUE, utext, ulength, TRUE, TRUE);
2959 EDIT_EM_SetSel(es, es->undo_position, es->undo_position + es->undo_insert_count, FALSE);
2960 /* send the notification after the selection start and end are set */
2961 if (!notify_parent(es, EN_CHANGE)) return TRUE;
2963 heap_free(utext);
2964
2965 TRACE("after UNDO:insertion length = %d, deletion buffer = %s\n",
2966 es->undo_insert_count, debugstr_w(es->undo_text));
2967 return TRUE;
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

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

◆ EDIT_GetCompositionStr()

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

Definition at line 4367 of file edit.c.

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

Referenced by EDIT_ImeComposition().

◆ EDIT_GetLineRect()

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

Definition at line 1147 of file edit.c.

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

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

◆ EDIT_GetResultStr()

static void EDIT_GetResultStr ( HIMC  hIMC,
EDITSTATE es 
)
static

Definition at line 4438 of file edit.c.

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

Referenced by EDIT_ImeComposition().

◆ EDIT_ImeComposition()

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

Definition at line 4473 of file edit.c.

4475{
4476 HIMC hIMC;
4477 int cursor;
4478
4479#ifdef __REACTOS__
4480 if (es->selection_start != es->selection_end)
4482#else
4483 if (es->composition_len == 0 && es->selection_start != es->selection_end)
4484 {
4486 es->composition_start = es->selection_end;
4487 }
4488#endif
4489
4490 hIMC = ImmGetContext(hwnd);
4491 if (!hIMC)
4492 return;
4493
4494 if (CompFlag & GCS_RESULTSTR)
4495 {
4496 EDIT_GetResultStr(hIMC, es);
4497 cursor = 0;
4498 }
4499 else
4500 {
4501 if (CompFlag & GCS_COMPSTR)
4502 EDIT_GetCompositionStr(hIMC, CompFlag, es);
4503#ifdef __REACTOS__
4504 cursor = 0;
4505#else
4507#endif
4508 }
4509 ImmReleaseContext(hwnd, hIMC);
4510 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
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

Referenced by EDIT_WindowProc().

◆ EDIT_InvalidateText()

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

Definition at line 1459 of file edit.c.

1461{
1462 if (end == start)
1463 return;
1464
1465 if (end == -1)
1467
1468 if (end < start) {
1469 INT tmp = start;
1470 start = end;
1471 end = tmp;
1472 }
1473
1474 if (es->style & ES_MULTILINE)
1476 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

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

◆ EDIT_InvalidateUniscribeData()

static void EDIT_InvalidateUniscribeData ( EDITSTATE es)
inlinestatic

Definition at line 315 of file edit.c.

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

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

◆ EDIT_InvalidateUniscribeData_linedef()

static void EDIT_InvalidateUniscribeData_linedef ( LINEDEF line_def)
inlinestatic

Definition at line 306 of file edit.c.

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

Referenced by EDIT_BuildLineDefs_ML(), and EDIT_InvalidateUniscribeData().

◆ EDIT_IsInsideDialog()

static BOOL EDIT_IsInsideDialog ( EDITSTATE es)
inlinestatic

Definition at line 2977 of file edit.c.

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

Referenced by EDIT_WM_Char(), and EDIT_WM_KeyDown().

◆ EDIT_LockBuffer()

static void EDIT_LockBuffer ( EDITSTATE es)
static

Definition at line 1211 of file edit.c.

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

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

◆ EDIT_MakeFit()

static BOOL EDIT_MakeFit ( EDITSTATE es,
UINT  size 
)
static

Definition at line 1276 of file edit.c.

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

Referenced by EDIT_EM_ReplaceSel().

◆ EDIT_MakeUndoFit()

static BOOL EDIT_MakeUndoFit ( EDITSTATE es,
UINT  size 
)
static

Definition at line 1317 of file edit.c.

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

Referenced by EDIT_EM_ReplaceSel().

◆ EDIT_ML_InvalidateText()

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

Definition at line 1394 of file edit.c.

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

Referenced by EDIT_InvalidateText().

◆ EDIT_MoveBackward()

static void EDIT_MoveBackward ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 1849 of file edit.c.

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

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

◆ EDIT_MoveDown_ML()

static void EDIT_MoveDown_ML ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 1876 of file edit.c.

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

Referenced by EDIT_WM_Char(), and EDIT_WM_KeyDown().

◆ EDIT_MoveEnd()

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

Definition at line 1898 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveForward()

static void EDIT_MoveForward ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 1919 of file edit.c.

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

Referenced by EDIT_WM_KeyDown(), and EDIT_WM_Timer().

◆ EDIT_MoveHome()

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

Definition at line 1944 of file edit.c.

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

Referenced by EDIT_WM_Char(), and EDIT_WM_KeyDown().

◆ EDIT_MovePageDown_ML()

static void EDIT_MovePageDown_ML ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 1968 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MovePageUp_ML()

static void EDIT_MovePageUp_ML ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 1996 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveUp_ML()

static void EDIT_MoveUp_ML ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2024 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveWordBackward()

static void EDIT_MoveWordBackward ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2046 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveWordForward()

static void EDIT_MoveWordForward ( EDITSTATE es,
BOOL  extend 
)
static

Definition at line 2077 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_NotifyCtlColor()

static HBRUSH EDIT_NotifyCtlColor ( EDITSTATE es,
HDC  hdc 
)
static

Definition at line 198 of file edit.c.

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

Referenced by EDIT_WM_Paint().

◆ EDIT_PaintLine()

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

Definition at line 2181 of file edit.c.

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

Referenced by EDIT_WM_Paint().

◆ EDIT_PaintText()

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

Definition at line 2107 of file edit.c.

2109{
2110 COLORREF BkColor;
2111 COLORREF TextColor;
2112 LOGFONTW underline_font;
2113 HFONT hUnderline = 0;
2114 HFONT old_font = 0;
2115 INT ret;
2116 INT li;
2117 INT BkMode;
2118 SIZE size;
2119
2120 if (!count)
2121 return 0;
2122 BkMode = GetBkMode(dc);
2123 BkColor = GetBkColor(dc);
2124 TextColor = GetTextColor(dc);
2125 if (rev) {
2126#ifdef __REACTOS__
2127 if (TRUE)
2128#else
2129 if (es->composition_len == 0)
2130#endif
2131 {
2134 SetBkMode( dc, OPAQUE);
2135 }
2136 else
2137 {
2139 GetObjectW(current,sizeof(LOGFONTW),&underline_font);
2140 underline_font.lfUnderline = TRUE;
2141 hUnderline = CreateFontIndirectW(&underline_font);
2142 old_font = SelectObject(dc,hUnderline);
2143 }
2144 }
2146 if (es->style & ES_MULTILINE) {
2147 ret = (INT)LOWORD(TabbedTextOutW(dc, x, y, es->text + li + col, count,
2148 es->tabs_count, es->tabs, es->format_rect.left - es->x_offset));
2149 } else {
2150 TextOutW(dc, x, y, es->text + li + col, count);
2151 GetTextExtentPoint32W(dc, es->text + li + col, count, &size);
2152 ret = size.cx;
2153 }
2154 if (rev) {
2155#ifdef __REACTOS__
2156 if (TRUE)
2157#else
2158 if (es->composition_len == 0)
2159#endif
2160 {
2161 SetBkColor(dc, BkColor);
2162 SetTextColor(dc, TextColor);
2163 SetBkMode( dc, BkMode);
2164 }
2165 else
2166 {
2167 if (old_font)
2168 SelectObject(dc,old_font);
2169 if (hUnderline)
2170 DeleteObject(hUnderline);
2171 }
2172 }
2173 return ret;
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
HFONT WINAPI CreateFontIndirectW(_In_ const LOGFONTW *)
int WINAPI SetBkMode(_In_ HDC, _In_ int)
Definition: dc.c:1056
BOOL WINAPI GetTextExtentPoint32W(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpString, _In_ int c, _Out_ LPSIZE psizl)
#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)

Referenced by EDIT_PaintLine().

◆ EDIT_Register()

void EDIT_Register ( void  )

Definition at line 5279 of file edit.c.

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

Referenced by DllMain().

◆ EDIT_SetCaretPos()

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

Definition at line 1750 of file edit.c.

1753{
1754 LRESULT res = EDIT_EM_PosFromChar(es, pos, after_wrap);
1755#ifdef __REACTOS__
1756 HKL hKL = GetKeyboardLayout(0);
1757 POINT pt = { (short)LOWORD(res), (short)HIWORD(res) };
1758
1759 /* Don't set caret if not focused */
1760 if ((es->flags & EF_FOCUSED) == 0)
1761 return;
1762
1763 SetCaretPos(pt.x, pt.y);
1764
1765 if (!ImmIsIME(hKL))
1766 return;
1767
1768 EDIT_ImmSetCompositionWindow(es, pt);
1769#else
1770 TRACE("%d - %dx%d\n", pos, (short)LOWORD(res), (short)HIWORD(res));
1771 SetCaretPos((short)LOWORD(res), (short)HIWORD(res));
1772#endif
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)

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

◆ EDIT_SetRectNP()

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

Definition at line 2319 of file edit.c.

2321{
2323 INT bw, bh;
2325
2326 CopyRect(&es->format_rect, rc);
2327
2328 if (ExStyle & WS_EX_CLIENTEDGE) {
2329 es->format_rect.left++;
2330 es->format_rect.right--;
2331
2332 if (es->format_rect.bottom - es->format_rect.top
2333 >= es->line_height + 2)
2334 {
2335 es->format_rect.top++;
2336 es->format_rect.bottom--;
2337 }
2338 }
2339 else if (es->style & WS_BORDER) {
2341 bh = GetSystemMetrics(SM_CYBORDER) + 1;
2342 InflateRect(&es->format_rect, -bw, 0);
2343 if (es->format_rect.bottom - es->format_rect.top >= es->line_height + 2 * bh)
2344 InflateRect(&es->format_rect, 0, -bh);
2345 }
2346
2347 es->format_rect.left += es->left_margin;
2348 es->format_rect.right -= es->right_margin;
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
BOOL WINAPI InflateRect(_Inout_ LPRECT, _In_ int, _In_ int)
int WINAPI GetSystemMetrics(_In_ int)
#define GWL_EXSTYLE
Definition: winuser.h:854

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

◆ EDIT_SL_InvalidateText()

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

Definition at line 1376 of file edit.c.

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

Referenced by EDIT_InvalidateText().

◆ EDIT_UnlockBuffer()

static void EDIT_UnlockBuffer ( EDITSTATE es,
BOOL  force 
)
static

Definition at line 1230 of file edit.c.

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

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

◆ EDIT_UpdateScrollInfo()

static void EDIT_UpdateScrollInfo ( EDITSTATE es)
static

Definition at line 1560 of file edit.c.

1562{
1563 if ((es->style & WS_VSCROLL) && !(es->flags & EF_VSCROLL_TRACK))
1564 {
1565 SCROLLINFO si;
1566 si.cbSize = sizeof(SCROLLINFO);
1568 si.nMin = 0;
1569 si.nMax = es->line_count - 1;
1570 si.nPage = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
1571 si.nPos = es->y_offset;
1572 TRACE("SB_VERT, nMin=%d, nMax=%d, nPage=%d, nPos=%d\n",
1573 si.nMin, si.nMax, si.nPage, si.nPos);
1574 SetScrollInfo(es->hwndSelf, SB_VERT, &si, TRUE);
1575 }
1576
1577 if ((es->style & WS_HSCROLL) && !(es->flags & EF_HSCROLL_TRACK))
1578 {
1579 SCROLLINFO si;
1580 si.cbSize = sizeof(SCROLLINFO);
1582 si.nMin = 0;
1583 si.nMax = es->text_width - 1;
1584 si.nPage = es->format_rect.right - es->format_rect.left;
1585 si.nPos = es->x_offset;
1586 TRACE("SB_HORZ, nMin=%d, nMax=%d, nPage=%d, nPos=%d\n",
1587 si.nMin, si.nMax, si.nPage, si.nPos);
1588 SetScrollInfo(es->hwndSelf, SB_HORZ, &si, TRUE);
1589 }
#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

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

◆ EDIT_UpdateText()

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

Definition at line 1359 of file edit.c.

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

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

◆ EDIT_UpdateTextRegion()

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

Definition at line 1344 of file edit.c.

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

Referenced by EDIT_EM_ReplaceSel().

◆ EDIT_UpdateUniscribeData()

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

Definition at line 372 of file edit.c.

374{
375 LINEDEF *line_def;
376
377 if (!(es->style & ES_MULTILINE))
378 {
379 if (!es->ssa)
380 {
382 HFONT old_font = NULL;
383 HDC udc = dc;
384
385 if (!udc)
386 udc = GetDC(es->hwndSelf);
387 if (es->font)
388 old_font = SelectObject(udc, es->font);
389
390 if (es->style & ES_PASSWORD)
391 ScriptStringAnalyse(udc, &es->password_char, length, (1.5*length+16), -1, SSA_LINK|SSA_FALLBACK|SSA_GLYPHS|SSA_PASSWORD, -1, NULL, NULL, NULL, NULL, NULL, &es->ssa);
392 else
393 ScriptStringAnalyse(udc, es->text, length, (1.5*length+16), -1, SSA_LINK|SSA_FALLBACK|SSA_GLYPHS, -1, NULL, NULL, NULL, NULL, NULL, &es->ssa);
394
395 if (es->font)
396 SelectObject(udc, old_font);
397 if (udc != dc)
398 ReleaseDC(es->hwndSelf, udc);
399 }
400 return es->ssa;
401 }
402 else
403 {
404 line_def = es->first_line_def;
405 while (line_def && line)
406 {
407 line_def = line_def->next;
408 line--;
409 }
410
411 return EDIT_UpdateUniscribeData_linedef(es,dc,line_def);
412 }
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

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

◆ EDIT_UpdateUniscribeData_linedef()

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

Definition at line 330 of file edit.c.

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

Referenced by EDIT_BuildLineDefs_ML(), and EDIT_UpdateUniscribeData().

◆ EDIT_WindowProc()

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

Definition at line 4717 of file edit.c.

4719{
4721 HTHEME theme = GetWindowTheme(hwnd);
4722 LRESULT result = 0;
4723 RECT *rect;
4724
4725 TRACE("hwnd=%p msg=%#x wparam=%lx lparam=%lx\n", hwnd, msg, wParam, lParam);
4726
4727 if (!es && msg != WM_NCCREATE)
4728 return DefWindowProcW(hwnd, msg, wParam, lParam);
4729
4730 if (es && (msg != WM_NCDESTROY))
4732
4733 switch (msg)
4734 {
4735 case EM_GETSEL:
4737 break;
4738
4739 case EM_SETSEL:
4742 result = 1;
4743 break;
4744
4745 case EM_GETRECT:
4746 rect = (RECT *)lParam;
4747 if (rect)
4748 *rect = es->format_rect;
4749 break;
4750
4751 case EM_SETRECT:
4752 if ((es->style & ES_MULTILINE) && lParam)
4753 {
4756 }
4757 break;
4758
4759 case EM_SETRECTNP:
4760 if ((es->style & ES_MULTILINE) && lParam)
4762 break;
4763
4764 case EM_SCROLL:
4766 break;
4767
4768 case EM_LINESCROLL:
4770 break;
4771
4772 case EM_SCROLLCARET:
4774 result = 1;
4775 break;
4776
4777 case EM_GETMODIFY:
4778 result = ((es->flags & EF_MODIFIED) != 0);
4779 break;
4780
4781 case EM_SETMODIFY:
4782 if (wParam)
4783 es->flags |= EF_MODIFIED;
4784 else
4785 es->flags &= ~(EF_MODIFIED | EF_UPDATE); /* reset pending updates */
4786 break;
4787
4788 case EM_GETLINECOUNT:
4789 result = (es->style & ES_MULTILINE) ? es->line_count : 1;
4790 break;
4791
4792 case EM_LINEINDEX:
4794 break;
4795
4796 case EM_SETHANDLE:
4798 break;
4799
4800 case EM_GETHANDLE:
4802 break;
4803
4804 case EM_GETTHUMB:
4806 break;
4807
4808 /* these messages missing from specs */
4809 case 0x00bf:
4810 case 0x00c0:
4811 case 0x00c3:
4812 case 0x00ca:
4813 FIXME("undocumented message 0x%x, please report\n", msg);
4815 break;
4816
4817 case EM_LINELENGTH:
4819 break;
4820
4821 case EM_REPLACESEL:
4822 {
4823 const WCHAR *textW = (const WCHAR *)lParam;
4824
4826 result = 1;
4827 break;
4828 }
4829
4830 case EM_GETLINE:
4832 break;
4833
4834 case EM_SETLIMITTEXT:
4836 break;
4837
4838 case EM_CANUNDO:
4840 break;
4841
4842 case EM_UNDO:
4843 case WM_UNDO:
4845 break;
4846
4847 case EM_FMTLINES:
4849 break;
4850
4851 case EM_LINEFROMCHAR:
4853 break;
4854
4855 case EM_SETTABSTOPS:
4857 break;
4858
4859 case EM_SETPASSWORDCHAR:
4861 break;
4862
4863 case EM_EMPTYUNDOBUFFER:
4865 break;
4866
4868 result = (es->style & ES_MULTILINE) ? es->y_offset : es->x_offset;
4869 break;
4870
4871 case EM_SETREADONLY:
4872 {
4873 DWORD old_style = es->style;
4874
4875 if (wParam)
4876 {
4878 es->style |= ES_READONLY;
4879 }
4880 else
4881 {
4883 es->style &= ~ES_READONLY;
4884 }
4885
4886 if (old_style ^ es->style)
4887 InvalidateRect(es->hwndSelf, NULL, TRUE);
4888
4889 result = 1;
4890 break;
4891 }
4892
4895 result = 1;
4896 break;
4897
4899 result = (LRESULT)es->word_break_proc;
4900 break;
4901
4902 case EM_GETPASSWORDCHAR:
4903 result = es->password_char;
4904 break;
4905
4906 case EM_SETMARGINS:
4908 break;
4909
4910 case EM_GETMARGINS:
4911 result = MAKELONG(es->left_margin, es->right_margin);
4912 break;
4913
4914 case EM_GETLIMITTEXT:
4915 result = es->buffer_limit;
4916 break;
4917
4918 case EM_POSFROMCHAR:
4919 if ((INT)wParam >= get_text_length(es)) result = -1;
4921 break;
4922
4923 case EM_CHARFROMPOS:
4924 result = EDIT_EM_CharFromPos(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
4925 break;
4926
4927 case EM_SETCUEBANNER:
4929 break;
4930
4931 case EM_GETCUEBANNER:
4933 break;
4934
4935 /* End of the EM_ messages which were in numerical order; what order
4936 * are these in? vaguely alphabetical?
4937 */
4938
4939 case WM_NCCREATE:
4941 break;
4942
4943 case WM_NCDESTROY:
4945 es = NULL;
4946 break;
4947
4948 case WM_GETDLGCODE:
4950
4951 if (es->style & ES_MULTILINE)
4953
4954 if (lParam)
4955 {
4956 MSG *msg = (MSG *)lParam;
4957 es->flags |= EF_DIALOGMODE;
4958
4959 if (msg->message == WM_KEYDOWN)
4960 {
4961 int vk = (int)msg->wParam;
4962
4963 if (es->hwndListBox)
4964 {
4965 if (vk == VK_RETURN || vk == VK_ESCAPE)
4968 }
4969 }
4970 }
4971 break;
4972
4973 case WM_IME_CHAR:
4974#ifdef __REACTOS__
4976 break;
4977#endif
4978 case WM_CHAR:
4979 {
4980 WCHAR charW = wParam;
4981
4982 if (es->hwndListBox)
4983 {
4984 if (charW == VK_RETURN || charW == VK_ESCAPE)
4985 {
4988 break;
4989 }
4990 }
4991 result = EDIT_WM_Char(es, charW);
4992 break;
4993 }
4994
4995 case WM_UNICHAR:
4996 if (wParam == UNICODE_NOCHAR) return TRUE;
4997 if (wParam <= 0x000fffff)
4998 {
4999 if (wParam > 0xffff) /* convert to surrogates */
5000 {
5001 wParam -= 0x10000;
5002 EDIT_WM_Char(es, (wParam >> 10) + 0xd800);
5003 EDIT_WM_Char(es, (wParam & 0x03ff) + 0xdc00);
5004 }
5005 else
5007 }
5008 return 0;
5009
5010 case WM_CLEAR:
5012 break;
5013
5014 case WM_CONTEXTMENU:
5015 EDIT_WM_ContextMenu(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
5016 break;
5017
5018 case WM_COPY:
5020 break;
5021
5022 case WM_CREATE:
5024 break;
5025
5026 case WM_CUT:
5027 EDIT_WM_Cut(es);
5028 break;
5029
5030 case WM_ENABLE:
5031 es->bEnableState = (BOOL) wParam;
5033 if (theme)
5035 break;
5036
5037 case WM_ERASEBKGND:
5038 /* we do the proper erase in EDIT_WM_Paint */
5039 result = 1;
5040 break;
5041
5042 case WM_GETFONT:
5043 result = (LRESULT)es->font;
5044 break;
5045
5046 case WM_GETTEXT:
5048 break;
5049
5050 case WM_GETTEXTLENGTH:
5052 break;
5053
5054 case WM_HSCROLL:
5056 break;
5057
5058 case WM_KEYDOWN:
5060 break;
5061
5062 case WM_KILLFOCUS:
5063 result = EDIT_WM_KillFocus(theme, es);
5064 break;
5065
5066 case WM_LBUTTONDBLCLK:
5068 break;
5069
5070 case WM_LBUTTONDOWN:
5072 break;
5073
5074 case WM_LBUTTONUP:
5076 break;
5077
5078 case WM_MBUTTONDOWN:
5080 break;
5081
5082 case WM_MOUSEMOVE:
5083 result = EDIT_WM_MouseMove(es, (short)LOWORD(lParam), (short)HIWORD(lParam));
5084 break;
5085
5086 case WM_PRINTCLIENT:
5087 case WM_PAINT:
5089 break;
5090
5091 case WM_NCPAINT:
5092 EDIT_WM_NCPaint(hwnd, (HRGN)wParam);
5093 break;
5094
5095 case WM_PASTE:
5097 break;
5098
5099 case WM_SETFOCUS:
5100 EDIT_WM_SetFocus(theme, es);
5101 break;
5102
5103 case WM_SETFONT:
5105 break;
5106
5107 case WM_SETREDRAW:
5108 /* FIXME: actually set an internal flag and behave accordingly */
5109 break;
5110
5111 case WM_SETTEXT:
5112 EDIT_WM_SetText(es, (const WCHAR *)lParam);
5113 result = TRUE;
5114 break;
5115
5116 case WM_SIZE:
5118 break;
5119
5120 case WM_STYLECHANGED:
5122 break;
5123
5124 case WM_STYLECHANGING:
5125 result = 0; /* See EDIT_WM_StyleChanged */
5126 break;
5127
5128 case WM_SYSKEYDOWN:
5130 break;
5131
5132 case WM_TIMER:
5134 break;
5135
5136 case WM_VSCROLL:
5138 break;
5139
5140 case WM_MOUSEWHEEL:
5141 {
5142 int wheelDelta;
5143 INT pulScrollLines = 3;
5144 SystemParametersInfoW(SPI_GETWHEELSCROLLLINES,0, &pulScrollLines, 0);
5145
5146 if (wParam & (MK_SHIFT | MK_CONTROL))
5147 {
5149 break;
5150 }
5151
5152 wheelDelta = GET_WHEEL_DELTA_WPARAM(wParam);
5153 /* if scrolling changes direction, ignore left overs */
5154 if ((wheelDelta < 0 && es->wheelDeltaRemainder < 0) ||
5155 (wheelDelta > 0 && es->wheelDeltaRemainder > 0))
5156 es->wheelDeltaRemainder += wheelDelta;
5157 else
5158 es->wheelDeltaRemainder = wheelDelta;
5159
5160 if (es->wheelDeltaRemainder && pulScrollLines)
5161 {
5162 int cLineScroll;
5163 pulScrollLines = min(es->line_count, pulScrollLines);
5164 cLineScroll = pulScrollLines * es->wheelDeltaRemainder / WHEEL_DELTA;
5165 es->wheelDeltaRemainder -= WHEEL_DELTA * cLineScroll / pulScrollLines;
5166 result = EDIT_EM_LineScroll(es, 0, -cLineScroll);
5167 }
5168 break;
5169 }
5170
5171 /* IME messages to make the edit control IME aware */
5172 case WM_IME_SETCONTEXT:
5173#ifdef __REACTOS__
5174 if (FALSE) /* FIXME: Condition */
5175 lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
5176
5177 if (wParam)
5178 {
5179 HIMC hIMC = ImmGetContext(hwnd);
5181 if (pIC)
5182 {
5183 pIC->dwUIFlags &= ~0x40000;
5184 ImmUnlockIMC(hIMC);
5185 }
5186 if (FALSE) /* FIXME: Condition */
5188 ImmReleaseContext(hwnd, hIMC);
5189 }
5190
5192#endif
5193 break;
5194
5195 case WM_IME_STARTCOMPOSITION:
5196#ifdef __REACTOS__
5197 if (FALSE) /* FIXME: Condition */
5198 return TRUE;
5200#else
5201 es->composition_start = es->selection_end;
5202 es->composition_len = 0;
5203#endif
5204 break;
5205
5206 case WM_IME_COMPOSITION:
5208#ifdef __REACTOS__
5210#endif
5211 break;
5212
5213 case WM_IME_ENDCOMPOSITION:
5214#ifdef __REACTOS__
5216#else
5217 if (es->composition_len > 0)
5218 {
5220 es->selection_end = es->selection_start;
5221 es->composition_len= 0;
5222 }
5223#endif
5224 break;
5225
5227 break;
5228
5229 case WM_IME_SELECT:
5230#ifdef __REACTOS__
5232#endif
5233 break;
5234
5235 case WM_IME_CONTROL:
5236#ifdef __REACTOS__
5238#endif
5239 break;
5240
5241 case WM_IME_REQUEST:
5242 switch (wParam)
5243 {
5244 case IMR_QUERYCHARPOSITION:
5245 {
5246 IMECHARPOSITION *chpos = (IMECHARPOSITION *)lParam;
5247 LRESULT pos;
5248
5249 pos = EDIT_EM_PosFromChar(es, es->selection_start + chpos->dwCharPos, FALSE);
5250 chpos->pt.x = LOWORD(pos);
5251 chpos->pt.y = HIWORD(pos);
5252 chpos->cLineHeight = es->line_height;
5253 chpos->rcDocument = es->format_rect;
5254 MapWindowPoints(hwnd, 0, &chpos->pt, 1);
5255 MapWindowPoints(hwnd, 0, (POINT*)&chpos->rcDocument, 2);
5256 result = 1;
5257 break;
5258 }
5259 }
5260 break;
5261
5262 case WM_THEMECHANGED:
5263 CloseThemeData (theme);
5265 break;
5266
5267 default:
5269 break;
5270 }
5271
5272 if (IsWindow(hwnd) && es && msg != EM_GETHANDLE)
5274
5275 TRACE("hwnd=%p msg=%x -- 0x%08lx\n", hwnd, msg, result);
5276
5277 return result;
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
static void EDIT_WM_Paint(EDITSTATE *es, HDC hdc)
Definition: edit.c:3620
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 void EDIT_WM_SetFont(EDITSTATE *es, HFONT font, BOOL redraw)
Definition: edit.c:3829
static LRESULT EDIT_WM_MButtonDown(EDITSTATE *es)
Definition: edit.c:3576
static void EDIT_SetRectNP(EDITSTATE *es, const RECT *rc)
Definition: edit.c:2319
static BOOL EDIT_EM_FmtLines(EDITSTATE *es, BOOL add_eol)
Definition: edit.c:2391
static void EDIT_WM_Copy(EDITSTATE *es)
Definition: edit.c:3024
static BOOL EDIT_EM_GetCueBanner(EDITSTATE *es, WCHAR *buf, DWORD size)
Definition: edit.c:4342
static LRESULT EDIT_EM_CharFromPos(EDITSTATE *es, INT x, INT y)
Definition: edit.c:2363
static void EDIT_WM_Cut(EDITSTATE *es)
Definition: edit.c:3068
static void EDIT_EM_SetPasswordChar(EDITSTATE *es, WCHAR c)
Definition: edit.c:2866
static void EDIT_WM_NCPaint(HWND hwnd, HRGN region)
Definition: edit.c:3709
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 BOOL EDIT_EM_Undo(EDITSTATE *es)
Definition: edit.c:2936
static void EDIT_WM_Paste(EDITSTATE *es)
Definition: edit.c:2988
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_Clear(EDITSTATE *es)
Definition: edit.c:3053
static BOOL EDIT_EM_CanUndo(const EDITSTATE *es)
Definition: edit.c:181
static void EDIT_EM_SetMargins(EDITSTATE *es, INT action, WORD left, WORD right, BOOL repaint)
Definition: edit.c:2794
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 BOOL EDIT_EM_SetCueBanner(EDITSTATE *es, BOOL draw_focused, const WCHAR *cue_text)
Definition: edit.c:4325
static LRESULT EDIT_EM_Scroll(EDITSTATE *es, INT action)
Definition: edit.c:1672
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
HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR classlist)
Definition: system.c:835
HTHEME WINAPI GetWindowTheme(HWND hwnd)
Definition: system.c:851
HRESULT WINAPI CloseThemeData(HTHEME hTheme)
Definition: system.c:950
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
static const WCHAR textW[]
Definition: itemdlg.c:1559
WORD vk
Definition: input.c:77
static HTHEME(WINAPI *pOpenThemeDataEx)(HWND
#define LRESULT
Definition: ole.h:14
#define EM_GETCUEBANNER
Definition: commctrl.h:4698
#define EM_SETCUEBANNER
Definition: commctrl.h:4696
#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
& rect
Definition: startmenu.cpp:1413
#define WHEEL_DELTA
Definition: treelist.c:99
#define WM_MOUSEWHEEL
Definition: treelist.c:96
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
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 MK_SHIFT
Definition: winuser.h:2372
#define WM_GETTEXTLENGTH
Definition: winuser.h:1622
#define EM_GETRECT
Definition: winuser.h:1999
#define WM_IME_REQUEST
Definition: winuser.h:1839
BOOL WINAPI RedrawWindow(_In_opt_ HWND, _In_opt_ LPCRECT, _In_opt_ HRGN, _In_ UINT)
#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
#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 RDW_UPDATENOW
Definition: winuser.h:1223
#define WM_LBUTTONDOWN
Definition: winuser.h:1779
#define EM_LINEINDEX
Definition: winuser.h:2005
int WINAPI MapWindowPoints(_In_opt_ HWND hWndFrom, _In_opt_ HWND hWndTo, _Inout_updates_(cPoints) LPPOINT lpPoints, _In_ UINT cPoints)
#define WM_GETFONT
Definition: winuser.h:1654
#define EM_LINESCROLL
Definition: winuser.h:2007
#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 VK_RETURN
Definition: winuser.h:2204
#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 RDW_FRAME
Definition: winuser.h:1215
#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 VK_ESCAPE
Definition: winuser.h:2217
#define DLGC_HASSETSEL
Definition: winuser.h:2617
#define WM_KILLFOCUS
Definition: winuser.h:1617
#define RDW_INVALIDATE
Definition: winuser.h:1217
#define WM_GETDLGCODE
Definition: winuser.h:1692
#define WM_MBUTTONDOWN
Definition: winuser.h:1785
#define EM_SETMODIFY
Definition: winuser.h:2016
#define WM_NCPAINT
Definition: winuser.h:1690
#define WM_SETREDRAW
Definition: winuser.h:1619

Referenced by EDIT_Register().

◆ EDIT_WM_Char()

static LRESULT EDIT_WM_Char ( EDITSTATE es,
WCHAR  c 
)
static

Definition at line 3080 of file edit.c.

3082{
3083 BOOL control;
3084
3085#ifdef __REACTOS__
3086 if (es->bCaptureState)
3087 return 0;
3088#endif
3089
3090 control = GetKeyState(VK_CONTROL) & 0x8000;
3091
3092 switch (c) {
3093 case '\r':
3094 /* If it's not a multiline edit box, it would be ignored below.
3095 * For multiline edit without ES_WANTRETURN, we have to make a
3096 * special case.
3097 */
3098 if ((es->style & ES_MULTILINE) && !(es->style & ES_WANTRETURN))
3100 break;
3101 case '\n':
3102 if (es->style & ES_MULTILINE) {
3103 if (es->style & ES_READONLY) {
3106 } else {
3107 static const WCHAR cr_lfW[] = {'\r','\n'};
3108 EDIT_EM_ReplaceSel(es, TRUE, cr_lfW, 2, TRUE, TRUE);
3109 }
3110 }
3111 break;
3112 case '\t':
3113 if ((es->style & ES_MULTILINE) && !(es->style & ES_READONLY))
3114 {
3115 static const WCHAR tabW[] = {'\t'};
3117 break;
3118 EDIT_EM_ReplaceSel(es, TRUE, tabW, 1, TRUE, TRUE);
3119 }
3120 break;
3121 case VK_BACK:
3122 if (!(es->style & ES_READONLY) && !control) {
3123 if (es->selection_start != es->selection_end)
3125 else {
3126 /* delete character left of caret */
3127 EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
3130 }
3131 }
3132 break;
3133 case 0x03: /* ^C */
3134 if (!(es->style & ES_PASSWORD))
3135 SendMessageW(es->hwndSelf, WM_COPY, 0, 0);
3136 break;
3137 case 0x16: /* ^V */
3138 if (!(es->style & ES_READONLY))
3139 SendMessageW(es->hwndSelf, WM_PASTE, 0, 0);
3140 break;
3141 case 0x18: /* ^X */
3142 if (!((es->style & ES_READONLY) || (es->style & ES_PASSWORD)))
3143 SendMessageW(es->hwndSelf, WM_CUT, 0, 0);
3144 break;
3145 case 0x1A: /* ^Z */
3146 if (!(es->style & ES_READONLY))
3147 SendMessageW(es->hwndSelf, WM_UNDO, 0, 0);
3148 break;
3149
3150 default:
3151 /*If Edit control style is ES_NUMBER allow users to key in only numeric values*/
3152 if( (es->style & ES_NUMBER) && !( c >= '0' && c <= '9') )
3153 break;
3154
3155 if (!(es->style & ES_READONLY) && (c >= ' ') && (c != 127))
3157 break;
3158 }
3159 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_MoveDown_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:1876
#define ES_WANTRETURN
Definition: pedump.c:676
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)

Referenced by EDIT_WindowProc().

◆ EDIT_WM_Clear()

static void EDIT_WM_Clear ( EDITSTATE es)
inlinestatic

Definition at line 3053 of file edit.c.

3055{
3056 /* Protect read-only edit control from modification */
3057 if(es->style & ES_READONLY)
3058 return;
3059

Referenced by EDIT_WindowProc(), EDIT_WM_Char(), EDIT_WM_Cut(), and EDIT_WM_KeyDown().

◆ EDIT_WM_ContextMenu()

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

Definition at line 3211 of file edit.c.

3213{
3214 HMENU menu = LoadMenuA(GetModuleHandleA("user32.dll"), "EDITMENU");
3215 HMENU popup = GetSubMenu(menu, 0);
3216 UINT start = es->selection_start;
3217 UINT end = es->selection_end;
3218 UINT cmd;
3219 POINT pt;
3220
3222
3223 /* undo */
3225 /* cut */
3226 EnableMenuItem(popup, 2, MF_BYPOSITION | ((end - start) && !(es->style & ES_PASSWORD) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
3227 /* copy */
3228 EnableMenuItem(popup, 3, MF_BYPOSITION | ((end - start) && !(es->style & ES_PASSWORD) ? MF_ENABLED : MF_GRAYED));
3229 /* paste */
3231 /* delete */
3232 EnableMenuItem(popup, 5, MF_BYPOSITION | ((end - start) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
3233 /* select all */
3235
3236 pt.x = x;
3237 pt.y = y;
3238
3239 if (pt.x == -1 && pt.y == -1) /* passed via VK_APPS press/release */
3240 {
3241 RECT rc;
3242
3243 /* Windows places the menu at the edit's center in this case */
3244 GetClientRect(es->hwndSelf, &rc);
3245 pt.x = rc.left + (rc.right - rc.left) / 2;
3246 pt.y = rc.top + (rc.bottom - rc.top) / 2;
3247 ClientToScreen(es->hwndSelf, &pt);
3248 }
3249
3250 if (!(es->flags & EF_FOCUSED))
3251 SetFocus(es->hwndSelf);
3252
3254 pt.x, pt.y, 0, es->hwndSelf, NULL);
3255
3256 if (cmd)
3258
3259 DestroyMenu(menu);
#define CF_UNICODETEXT
Definition: constants.h:408
static void EDIT_ContextMenuCommand(EDITSTATE *es, UINT id)
Definition: edit.c:3167
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
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 TPM_RIGHTBUTTON
Definition: winuser.h:2383
#define TPM_NONOTIFY
Definition: winuser.h:2389
BOOL WINAPI ClientToScreen(_In_ HWND, _Inout_ LPPOINT)
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)

Referenced by EDIT_WindowProc().

◆ EDIT_WM_Copy()

static void EDIT_WM_Copy ( EDITSTATE es)
static

Definition at line 3024 of file edit.c.

3026{
3027 INT s = min(es->selection_start, es->selection_end);
3028 INT e = max(es->selection_start, es->selection_end);
3029 HGLOBAL hdst;
3030 LPWSTR dst;
3031 DWORD len;
3032
3033 if (e == s) return;
3034
3035 len = e - s;
3036 hdst = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (len + 1) * sizeof(WCHAR));
3037 dst = GlobalLock(hdst);
3038 memcpy(dst, es->text + s, len * sizeof(WCHAR));
3039 dst[len] = 0; /* ensure 0 termination */
3040 TRACE("%s\n", debugstr_w(dst));
3041 GlobalUnlock(hdst);
3042 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

Referenced by EDIT_WindowProc(), EDIT_WM_Cut(), and EDIT_WM_KeyDown().

◆ EDIT_WM_Create()

static LRESULT EDIT_WM_Create ( EDITSTATE es,
const WCHAR name 
)
static

Definition at line 4632 of file edit.c.

4634{
4635 RECT clientRect;
4636
4637 TRACE("%s\n", debugstr_w(name));
4638
4639 /*
4640 * To initialize some final structure members, we call some helper
4641 * functions. However, since the EDITSTATE is not consistent (i.e.
4642 * not fully initialized), we should be very careful which
4643 * functions can be called, and in what order.
4644 */
4647
4648 /* We need to calculate the format rect
4649 (applications may send EM_SETMARGINS before the control gets visible) */
4650 GetClientRect(es->hwndSelf, &clientRect);
4651 EDIT_SetRectNP(es, &clientRect);
4652
4653 if (name && *name)
4654 {
4656 /* if we insert text to the editline, the text scrolls out
4657 * of the window, as the caret is placed after the insert
4658 * pos normally; thus we reset es->selection... to 0 and
4659 * update caret
4660 */
4661 es->selection_start = es->selection_end = 0;
4662 /* Adobe Photoshop does NOT like this. and MSDN says that EN_CHANGE
4663 * Messages are only to be sent when the USER does something to
4664 * change the contents. So I am removing this EN_CHANGE
4665 *
4666 * EDIT_NOTIFY_PARENT(es, EN_CHANGE);
4667 */
4669 }
4670
4671 /* force scroll info update */
4673 OpenThemeData(es->hwndSelf, WC_EDITW);
4674
4675 /* The rule seems to return 1 here for success */
4676 /* Power Builder masked edit controls will crash */
4677 /* if not. */
4678 /* FIXME: is that in all cases so ? */
4679 return 1;
Definition: name.c:39

Referenced by EDIT_WindowProc().

◆ EDIT_WM_Cut()

static void EDIT_WM_Cut ( EDITSTATE es)
inlinestatic

Definition at line 3068 of file edit.c.

3070{

Referenced by EDIT_WindowProc(), and EDIT_WM_KeyDown().

◆ EDIT_WM_GetText()

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

Definition at line 3267 of file edit.c.

3269{
3270 if (!count)
3271 return 0;
3272
3273 lstrcpynW(dst, es->text, count);
3274 return lstrlenW(dst);

Referenced by EDIT_WindowProc().

◆ EDIT_WM_HScroll()

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

Definition at line 4054 of file edit.c.

4056{
4057 INT dx;
4058 INT fw;
4059
4060 if (!(es->style & ES_MULTILINE))
4061 return 0;
4062
4063 if (!(es->style & ES_AUTOHSCROLL))
4064 return 0;
4065
4066 dx = 0;
4067 fw = es->format_rect.right - es->format_rect.left;
4068 switch (action) {
4069 case SB_LINELEFT:
4070 TRACE("SB_LINELEFT\n");
4071 if (es->x_offset)
4072 dx = -es->char_width;
4073 break;
4074 case SB_LINERIGHT:
4075 TRACE("SB_LINERIGHT\n");
4076 if (es->x_offset < es->text_width)
4077 dx = es->char_width;
4078 break;
4079 case SB_PAGELEFT:
4080 TRACE("SB_PAGELEFT\n");
4081 if (es->x_offset)
4082 dx = -fw / HSCROLL_FRACTION / es->char_width * es->char_width;
4083 break;
4084 case SB_PAGERIGHT:
4085 TRACE("SB_PAGERIGHT\n");
4086 if (es->x_offset < es->text_width)
4087 dx = fw / HSCROLL_FRACTION / es->char_width * es->char_width;
4088 break;
4089 case SB_LEFT:
4090 TRACE("SB_LEFT\n");
4091 if (es->x_offset)
4092 dx = -es->x_offset;
4093 break;
4094 case SB_RIGHT:
4095 TRACE("SB_RIGHT\n");
4096 if (es->x_offset < es->text_width)
4097 dx = es->text_width - es->x_offset;
4098 break;
4099 case SB_THUMBTRACK:
4100 TRACE("SB_THUMBTRACK %d\n", pos);
4101 es->flags |= EF_HSCROLL_TRACK;
4102 if(es->style & WS_HSCROLL)
4103 dx = pos - es->x_offset;
4104 else
4105 {
4106 INT fw, new_x;
4107 /* Sanity check */
4108 if(pos < 0 || pos > 100) return 0;
4109 /* Assume default scroll range 0-100 */
4110 fw = es->format_rect.right - es->format_rect.left;
4111 new_x = pos * (es->text_width - fw) / 100;
4112 dx = es->text_width ? (new_x - es->x_offset) : 0;
4113 }
4114 break;
4115 case SB_THUMBPOSITION:
4116 TRACE("SB_THUMBPOSITION %d\n", pos);
4117 es->flags &= ~EF_HSCROLL_TRACK;
4118 if(GetWindowLongW( es->hwndSelf, GWL_STYLE ) & WS_HSCROLL)
4119 dx = pos - es->x_offset;
4120 else
4121 {
4122 INT fw, new_x;
4123 /* Sanity check */
4124 if(pos < 0 || pos > 100) return 0;
4125 /* Assume default scroll range 0-100 */
4126 fw = es->format_rect.right - es->format_rect.left;
4127 new_x = pos * (es->text_width - fw) / 100;
4128 dx = es->text_width ? (new_x - es->x_offset) : 0;
4129 }
4130 if (!dx) {
4131 /* force scroll info update */
4134 }
4135 break;
4136 case SB_ENDSCROLL:
4137 TRACE("SB_ENDSCROLL\n");
4138 break;
4139 /*
4140 * FIXME : the next two are undocumented !
4141 * Are we doing the right thing ?
4142 * At least Win 3.1 Notepad makes use of EM_GETTHUMB this way,
4143 * although it's also a regular control message.
4144 */
4145 case EM_GETTHUMB: /* this one is used by NT notepad */
4146 {
4147 LRESULT ret;
4148 if(GetWindowLongW( es->hwndSelf, GWL_STYLE ) & WS_HSCROLL)
4149 ret = GetScrollPos(es->hwndSelf, SB_HORZ);
4150 else
4151 {
4152 /* Assume default scroll range 0-100 */
4153 INT fw = es->format_rect.right - es->format_rect.left;
4154 ret = es->text_width ? es->x_offset * 100 / (es->text_width - fw) : 0;
4155 }
4156 TRACE("EM_GETTHUMB: returning %ld\n", ret);
4157 return ret;
4158 }
4159 case EM_LINESCROLL:
4160 TRACE("EM_LINESCROLL16\n");
4161 dx = pos;
4162 break;
4163
4164 default:
4165 ERR("undocumented WM_HSCROLL action %d (0x%04x), please report\n",
4166 action, action);
4167 return 0;
4168 }
4169 if (dx)
4170 {
4171 INT fw = es->format_rect.right - es->format_rect.left;
4172 /* check if we are going to move too far */
4173 if(es->x_offset + dx + fw > es->text_width)
4174 dx = es->text_width - fw - es->x_offset;
4175 if(dx)
4177 }
4178 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 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

Referenced by EDIT_EM_GetThumb(), and EDIT_WindowProc().

◆ EDIT_WM_KeyDown()

static LRESULT EDIT_WM_KeyDown ( EDITSTATE es,
INT  key 
)
static

Definition at line 3343 of file edit.c.

3345{
3346 BOOL shift;
3347 BOOL control;
3348
3349 if (GetKeyState(VK_MENU) & 0x8000)
3350 return 0;
3351
3352 shift = GetKeyState(VK_SHIFT) & 0x8000;
3353 control = GetKeyState(VK_CONTROL) & 0x8000;
3354
3355 switch (key) {
3356 case VK_F4:
3357 case VK_UP:
3359 break;
3360
3361 /* fall through */
3362 case VK_LEFT:
3363 if ((es->style & ES_MULTILINE) && (key == VK_UP))
3365 else
3366 if (control)
3368 else
3370 break;
3371 case VK_DOWN:
3373 break;
3374 /* fall through */
3375 case VK_RIGHT:
3376 if ((es->style & ES_MULTILINE) && (key == VK_DOWN))
3378 else if (control)
3380 else
3382 break;
3383 case VK_HOME:
3385 break;
3386 case VK_END:
3388 break;
3389 case VK_PRIOR:
3390 if (es->style & ES_MULTILINE)
3392 else
3394 break;
3395 case VK_NEXT:
3396 if (es->style & ES_MULTILINE)
3398 else
3400 break;
3401 case VK_DELETE:
3402 if (!(es->style & ES_READONLY) && !(shift && control)) {
3403 if (es->selection_start != es->selection_end) {
3404 if (shift)
3405 EDIT_WM_Cut(es);
3406 else
3408 } else {
3409 EDIT_EM_SetSel(es, ~0u, 0, FALSE);
3410 if (shift)
3411 /* delete character left of caret */
3413 else if (control)
3414 /* delete to end of line */
3416 else
3417 /* delete character right of caret */
3420 }
3421 }
3422 break;
3423 case VK_INSERT:
3424 if (shift) {
3425 if (!(es->style & ES_READONLY))
3427 } else if (control)
3429 break;
3430 case VK_RETURN:
3431 /* If the edit doesn't want the return send a message to the default object */
3432 if(!(es->style & ES_MULTILINE) || !(es->style & ES_WANTRETURN))
3433 {
3434 DWORD dw;
3435
3436 if (!EDIT_IsInsideDialog(es)) break;
3437 if (control) break;
3438 dw = SendMessageW(es->hwndParent, DM_GETDEFID, 0, 0);
3439 if (HIWORD(dw) == DC_HASDEFID)
3440 {
3441 HWND hwDefCtrl = GetDlgItem(es->hwndParent, LOWORD(dw));
3442 if (hwDefCtrl)
3443 {
3444 SendMessageW(es->hwndParent, WM_NEXTDLGCTL, (WPARAM)hwDefCtrl, TRUE);
3445 PostMessageW(hwDefCtrl, WM_KEYDOWN, VK_RETURN, 0);
3446 }
3447 }
3448 }
3449 break;
3450 case VK_ESCAPE:
3451 if ((es->style & ES_MULTILINE) && EDIT_IsInsideDialog(es))
3452 PostMessageW(es->hwndParent, WM_CLOSE, 0, 0);
3453 break;
3454 case VK_TAB:
3455 if ((es->style & ES_MULTILINE) && EDIT_IsInsideDialog(es))
3456 SendMessageW(es->hwndParent, WM_NEXTDLGCTL, shift, 0);
3457 break;
3458 case 'A':
3459 if (control)
3460 {
3462 {
3463 if (!notify_parent(es, EN_UPDATE)) break;
3465 }
3466 }
3467 break;
3468 }
3469 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_MovePageUp_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:1996
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_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_INSERT
Definition: winuser.h:2235
#define VK_MENU
Definition: winuser.h:2207

Referenced by EDIT_WindowProc().

◆ EDIT_WM_KillFocus()

static LRESULT EDIT_WM_KillFocus ( HTHEME  theme,
EDITSTATE es 
)
static

Definition at line 3477 of file edit.c.

3479{
3481 HWND hwndSelf = es->hwndSelf;
3482
3483 es->flags &= ~EF_FOCUSED;
3484 DestroyCaret();
3485 if (!(es->style & ES_NOHIDESEL))
3486 EDIT_InvalidateText(es, es->selection_start, es->selection_end);
3487 if (!notify_parent(es, EN_KILLFOCUS)) return 0;
3488 /* Throw away left over scroll when we lose focus */
3489 es->wheelDeltaRemainder = 0;
3490
3491 if (theme)
3492 flags |= RDW_FRAME;
3493
3494 RedrawWindow(hwndSelf, NULL, NULL, flags);
3495 return 0;
GLbitfield flags
Definition: glext.h:7161
#define EN_KILLFOCUS
Definition: winuser.h:2028
BOOL WINAPI DestroyCaret(void)
Definition: caret.c:35

Referenced by EDIT_WindowProc().

◆ EDIT_WM_LButtonDblClk()

static LRESULT EDIT_WM_LButtonDblClk ( EDITSTATE es)
static

Definition at line 3505 of file edit.c.

3507{
3508 INT s;
3509 INT e = es->selection_end;
3510 INT l;
3511 INT li;
3512 INT ll;
3513
3514 es->bCaptureState = TRUE;
3515 SetCapture(es->hwndSelf);
3516
3524 es->region_posx = es->region_posy = 0;
3525 SetTimer(es->hwndSelf, 0, 100, NULL);
3526 return 0;
HWND WINAPI SetCapture(_In_ HWND hWnd)
UINT_PTR WINAPI SetTimer(_In_opt_ HWND, _In_ UINT_PTR, _In_ UINT, _In_opt_ TIMERPROC)

Referenced by EDIT_WindowProc().

◆ EDIT_WM_LButtonDown()

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

Definition at line 3534 of file edit.c.

3536{
3537 INT e;
3538 BOOL after_wrap;
3539
3540 es->bCaptureState = TRUE;
3541 SetCapture(es->hwndSelf);
3542 EDIT_ConfinePoint(es, &x, &y);
3543 e = EDIT_CharFromPos(es, x, y, &after_wrap);
3544 EDIT_EM_SetSel(es, (keys & MK_SHIFT) ? es->selection_start : e, e, after_wrap);
3546 es->region_posx = es->region_posy = 0;
3547 SetTimer(es->hwndSelf, 0, 100, NULL);
3548
3549 if (!(es->flags & EF_FOCUSED))
3550 SetFocus(es->hwndSelf);
3551
3552 return 0;
static void EDIT_ConfinePoint(const EDITSTATE *es, LPINT x, LPINT y)
Definition: edit.c:901

Referenced by EDIT_WindowProc().

◆ EDIT_WM_LButtonUp()

static LRESULT EDIT_WM_LButtonUp ( EDITSTATE es)
static

Definition at line 3560 of file edit.c.

3562{
3563 if (es->bCaptureState) {
3564 KillTimer(es->hwndSelf, 0);
3565 if (GetCapture() == es->hwndSelf) ReleaseCapture();
3566 }
3567 es->bCaptureState = FALSE;
3568 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)

Referenced by EDIT_WindowProc().

◆ EDIT_WM_MButtonDown()

static LRESULT EDIT_WM_MButtonDown ( EDITSTATE es)
static

Definition at line 3576 of file edit.c.

3578{
3579 SendMessageW(es->hwndSelf, WM_PASTE, 0, 0);
3580 return 0;

Referenced by EDIT_WindowProc().

◆ EDIT_WM_MouseMove()

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

Definition at line 3588 of file edit.c.

3590{
3591 INT e;
3592 BOOL after_wrap;
3593 INT prex, prey;
3594
3595 /* If the mouse has been captured by process other than the edit control itself,
3596 * the windows edit controls will not select the strings with mouse move.
3597 */
3598 if (!es->bCaptureState || GetCapture() != es->hwndSelf)
3599 return 0;
3600
3601 /*
3602 * FIXME: gotta do some scrolling if outside client
3603 * area. Maybe reset the timer ?
3604 */
3605 prex = x; prey = y;
3606 EDIT_ConfinePoint(es, &x, &y);
3607 es->region_posx = (prex < x) ? -1 : ((prex > x) ? 1 : 0);
3608 es->region_posy = (prey < y) ? -1 : ((prey > y) ? 1 : 0);
3609 e = EDIT_CharFromPos(es, x, y, &after_wrap);
3610 EDIT_EM_SetSel(es, es->selection_start, e, after_wrap);
3611 EDIT_SetCaretPos(es,es->selection_end,es->flags & EF_AFTER_WRAP);
3612 return 0;

Referenced by EDIT_WindowProc().

◆ EDIT_WM_NCCreate()

static LRESULT EDIT_WM_NCCreate ( HWND  hwnd,
LPCREATESTRUCTW  lpcs 
)
static

Definition at line 4519 of file edit.c.

4521{
4522 EDITSTATE *es;
4523 UINT alloc_size;
4524
4525 TRACE("Creating edit control, style = %08x\n", lpcs->style);
4526
4527 if (!(es = heap_alloc_zero(sizeof(*es))))
4528 return FALSE;
4530
4531 /*
4532 * Note: since the EDITSTATE has not been fully initialized yet,
4533 * we can't use any API calls that may send
4534 * WM_XXX messages before WM_NCCREATE is completed.
4535 */
4536
4537 es->style = lpcs->style;
4538
4539 es->bEnableState = !(es->style & WS_DISABLED);
4540
4541 es->hwndSelf = hwnd;
4542 /* Save parent, which will be notified by EN_* messages */
4543 es->hwndParent = lpcs->hwndParent;
4544
4545 if (es->style & ES_COMBO)
4546 es->hwndListBox = GetDlgItem(es->hwndParent, ID_CB_LISTBOX);
4547
4548 /* FIXME: should we handle changes to WS_EX_RIGHT style after creation? */
4549 if (lpcs->dwExStyle & WS_EX_RIGHT) es->style |= ES_RIGHT;
4550
4551 /* Number overrides lowercase overrides uppercase (at least it
4552 * does in Win95). However I'll bet that ES_NUMBER would be
4553 * invalid under Win 3.1.
4554 */
4555 if (es->style & ES_NUMBER) {
4556 ; /* do not override the ES_NUMBER */
4557 } else if (es->style & ES_LOWERCASE) {
4558 es->style &= ~ES_UPPERCASE;
4559 }
4560 if (es->style & ES_MULTILINE) {
4561 es->buffer_limit = BUFLIMIT_INITIAL;
4562 if (es->style & WS_VSCROLL)
4563 es->style |= ES_AUTOVSCROLL;
4564 if (es->style & WS_HSCROLL)
4565 es->style |= ES_AUTOHSCROLL;
4566 es->style &= ~ES_PASSWORD;
4567 if ((es->style & ES_CENTER) || (es->style & ES_RIGHT)) {
4568 /* Confirmed - RIGHT overrides CENTER */
4569 if (es->style & ES_RIGHT)
4570 es->style &= ~ES_CENTER;
4571 es->style &= ~WS_HSCROLL;
4572 es->style &= ~ES_AUTOHSCROLL;
4573 }
4574 } else {
4575 es->buffer_limit = BUFLIMIT_INITIAL;
4576 if ((es->style & ES_RIGHT) && (es->style & ES_CENTER))
4577 es->style &= ~ES_CENTER;
4578 es->style &= ~WS_HSCROLL;
4579 es->style &= ~WS_VSCROLL;
4580 if (es->style & ES_PASSWORD)
4581 es->password_char = '*';
4582 }
4583
4584 alloc_size = ROUND_TO_GROW((es->buffer_size + 1) * sizeof(WCHAR));
4585 if(!(es->hloc32W = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, alloc_size)))
4586 goto cleanup;
4587 es->buffer_size = LocalSize(es->hloc32W)/sizeof(WCHAR) - 1;
4588
4589 if (!(es->undo_text = heap_alloc_zero((es->buffer_size + 1) * sizeof(WCHAR))))
4590 goto cleanup;
4591 es->undo_buffer_size = es->buffer_size;
4592
4593 if (es->style & ES_MULTILINE)
4594 if (!(es->first_line_def = heap_alloc_zero(sizeof(LINEDEF))))
4595 goto cleanup;
4596 es->line_count = 1;
4597
4598 /*
4599 * In Win95 look and feel, the WS_BORDER style is replaced by the
4600 * WS_EX_CLIENTEDGE style for the edit control. This gives the edit
4601 * control a nonclient area so we don't need to draw the border.
4602 * If WS_BORDER without WS_EX_CLIENTEDGE is specified we shouldn't have
4603 * a nonclient area and we should handle painting the border ourselves.
4604 *
4605 * When making modifications please ensure that the code still works
4606 * for edit controls created directly with style 0x50800000, exStyle 0
4607 * (which should have a single pixel border)
4608 */
4609 if (lpcs->dwExStyle & WS_EX_CLIENTEDGE)
4610 es->style &= ~WS_BORDER;
4611 else if (es->style & WS_BORDER)
4613
4614 return TRUE;
4615
4616cleanup:
4617 SetWindowLongPtrW(es->hwndSelf, 0, 0);
4619 heap_free(es->first_line_def);
4620 heap_free(es->undo_text);
4621 if (es->hloc32W) LocalFree(es->hloc32W);
4622 heap_free(es->logAttr);
4623 heap_free(es);
4624 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
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
#define ES_COMBO
Definition: edit.c:29
#define WS_DISABLED
Definition: pedump.c:621
#define SetWindowLongPtrW
Definition: winuser.h:5358
#define WS_EX_RIGHT
Definition: winuser.h:400

Referenced by EDIT_WindowProc().

◆ EDIT_WM_NCDestroy()

static LRESULT EDIT_WM_NCDestroy ( EDITSTATE es)
static

Definition at line 4687 of file edit.c.

4689{
4690 LINEDEF *pc, *pp;
4691 HTHEME theme;
4692
4693 theme = GetWindowTheme(es->hwndSelf);
4694 CloseThemeData(theme);
4695
4696 /* The app can own the text buffer handle */
4697 if (es->hloc32W && (es->hloc32W != es->hlocapp))
4698 LocalFree(es->hloc32W);
4699
4701
4702 pc = es->first_line_def;
4703 while (pc)
4704 {
4705 pp = pc->next;
4706 heap_free(pc);
4707 pc = pp;
4708 }
4709
4710 SetWindowLongPtrW( es->hwndSelf, 0, 0 );
4711 heap_free(es->undo_text);
4712 heap_free(es->cue_banner_text);
4713 heap_free(es);
4714
4715 return 0;

Referenced by EDIT_WindowProc().

◆ EDIT_WM_NCPaint()

static void EDIT_WM_NCPaint ( HWND  hwnd,
HRGN  region 
)
static

Definition at line 3709 of file edit.c.

3711{
3713 HTHEME theme = GetWindowTheme(hwnd);
3714 HRGN cliprgn = region;
3715
3716 if (theme && exStyle & WS_EX_CLIENTEDGE)
3717 {
3718 HDC dc;
3719 RECT r;
3720 int cxEdge = GetSystemMetrics(SM_CXEDGE),
3721 cyEdge = GetSystemMetrics(SM_CYEDGE);
3722 const int part = EP_EDITTEXT;
3723 int state = ETS_NORMAL;
3724 DWORD dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
3725
3726 if (!IsWindowEnabled(hwnd))
3728 else if (dwStyle & ES_READONLY)
3730 else if (GetFocus() == hwnd)
3732
3733 GetWindowRect(hwnd, &r);
3734
3735 /* New clipping region passed to default proc to exclude border */
3736 cliprgn = CreateRectRgn(r.left + cxEdge, r.top + cyEdge,
3737 r.right - cxEdge, r.bottom - cyEdge);
3738 if (region != (HRGN)1)
3739 CombineRgn(cliprgn, cliprgn, region, RGN_AND);
3740 OffsetRect(&r, -r.left, -r.top);
3741
3742#ifdef __REACTOS__ /* r73789 */
3743 dc = GetWindowDC(hwnd);
3744 /* Exclude client part */
3746 r.left + cxEdge,
3747 r.top + cyEdge,
3748 r.right - cxEdge,
3749 r.bottom -cyEdge);
3750#else
3752 OffsetRect(&r, -r.left, -r.top);
3753#endif
3754
3757 DrawThemeBackground(theme, dc, part, state, &r, 0);
3758 ReleaseDC(hwnd, dc);
3759 }
3760
3761 /* Call default proc to get the scrollbars etc. also painted */
3762 DefWindowProcW (hwnd, WM_NCPAINT, (WPARAM)cliprgn, 0);
3763 if (cliprgn != region)
3764 DeleteObject(cliprgn);
static int state
Definition: maze.c:121
HRESULT WINAPI DrawThemeBackground(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const RECT *pClipRect)
Definition: draw.c:128
BOOL WINAPI IsThemeBackgroundPartiallyTransparent(HTHEME hTheme, int iPartId, int iStateId)
Definition: draw.c:1927
HRESULT WINAPI DrawThemeParentBackground(HWND hwnd, HDC hdc, RECT *prc)
Definition: draw.c:72
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
@ EP_EDITTEXT
Definition: vsstyle.h:419
@ ETS_DISABLED
Definition: vsstyle.h:436
@ ETS_READONLY
Definition: vsstyle.h:438
@ ETS_NORMAL
Definition: vsstyle.h:433
@ ETS_FOCUSED
Definition: vsstyle.h:437
int WINAPI ExcludeClipRect(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
#define RGN_AND
Definition: wingdi.h:356
HWND WINAPI GetFocus(void)
Definition: window.c:1865
HDC WINAPI GetWindowDC(_In_opt_ HWND)
#define SM_CYEDGE
Definition: winuser.h:1012
#define DCX_WINDOW
Definition: winuser.h:2116
#define SM_CXEDGE
Definition: winuser.h:1011
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
HDC WINAPI GetDCEx(_In_opt_ HWND, _In_opt_ HRGN, _In_ DWORD)
#define DCX_INTERSECTRGN
Definition: winuser.h:2125
BOOL WINAPI IsWindowEnabled(_In_ HWND)
BOOL WINAPI OffsetRect(_Inout_ LPRECT, _In_ int, _In_ int)

Referenced by EDIT_WindowProc().

◆ EDIT_WM_Paint()

static void EDIT_WM_Paint ( EDITSTATE es,
HDC  hdc 
)
static

Definition at line 3620 of file edit.c.

3622{
3623 PAINTSTRUCT ps;
3624 INT i;
3625 HDC dc;
3626 HFONT old_font = 0;
3627 RECT rc;
3628 RECT rcClient;
3629 RECT rcLine;
3630 RECT rcRgn;
3631 HBRUSH brush;
3632 HBRUSH old_brush;
3633 INT bw, bh;
3634 BOOL rev = es->bEnableState &&
3635 ((es->flags & EF_FOCUSED) ||
3636 (es->style & ES_NOHIDESEL));
3637 dc = hdc ? hdc : BeginPaint(es->hwndSelf, &ps);
3638
3639 /* The dc we use for calculating may not be the one we paint into.
3640 This is the safest action. */
3642 GetClientRect(es->hwndSelf, &rcClient);
3643
3644 /* get the background brush */
3645 brush = EDIT_NotifyCtlColor(es, dc);
3646
3647 /* paint the border and the background */
3648 IntersectClipRect(dc, rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
3649
3650 if(es->style & WS_BORDER) {
3653 rc = rcClient;
3654 if(es->style & ES_MULTILINE) {
3655 if(es->style & WS_HSCROLL) rc.bottom+=bh;
3656 if(es->style & WS_VSCROLL) rc.right+=bw;
3657 }
3658
3659 /* Draw the frame. Same code as in nonclient.c */
3661 PatBlt(dc, rc.left, rc.top, rc.right - rc.left, bh, PATCOPY);
3662 PatBlt(dc, rc.left, rc.top, bw, rc.bottom - rc.top, PATCOPY);
3663 PatBlt(dc, rc.left, rc.bottom - 1, rc.right - rc.left, -bw, PATCOPY);
3664 PatBlt(dc, rc.right - 1, rc.top, -bw, rc.bottom - rc.top, PATCOPY);
3665 SelectObject(dc, old_brush);
3666
3667 /* Keep the border clean */
3668 IntersectClipRect(dc, rc.left+bw, rc.top+bh,
3669 max(rc.right-bw, rc.left+bw), max(rc.bottom-bh, rc.top+bh));
3670 }
3671
3672 GetClipBox(dc, &rc);
3673 FillRect(dc, &rc, brush);
3674
3675 IntersectClipRect(dc, es->format_rect.left,
3676 es->format_rect.top,
3677 es->format_rect.right,
3678 es->format_rect.bottom);
3679 if (es->style & ES_MULTILINE) {
3680 rc = rcClient;
3681 IntersectClipRect(dc, rc.left, rc.top, rc.right, rc.bottom);
3682 }
3683 if (es->font)
3684 old_font = SelectObject(dc, es->font);
3685
3686 if (!es->bEnableState)
3688 GetClipBox(dc, &rcRgn);
3689 if (es->style & ES_MULTILINE) {
3691 for (i = es->y_offset ; i <= min(es->y_offset + vlc, es->y_offset + es->line_count - 1) ; i++) {
3693 EDIT_GetLineRect(es, i, 0, -1, &rcLine);
3694 if (IntersectRect(&rc, &rcRgn, &rcLine))
3695 EDIT_PaintLine(es, dc, i, rev);
3696 }
3697 } else {
3699 EDIT_GetLineRect(es, 0, 0, -1, &rcLine);
3700 if (IntersectRect(&rc, &rcRgn, &rcLine))
3701 EDIT_PaintLine(es, dc, 0, rev);
3702 }
3703 if (es->font)
3704 SelectObject(dc, old_font);
3705
3706 if (!hdc)
3707 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_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)

Referenced by EDIT_WindowProc(), and EDIT_WM_SetFocus().

◆ EDIT_WM_Paste()

static void EDIT_WM_Paste ( EDITSTATE es)
static

Definition at line 2988 of file edit.c.

2990{
2991 HGLOBAL hsrc;
2992 LPWSTR src, ptr;
2993 int len;
2994
2995 /* Protect read-only edit control from modification */
2996 if(es->style & ES_READONLY)
2997 return;
2998
2999 OpenClipboard(es->hwndSelf);
3000 if ((hsrc = GetClipboardData(CF_UNICODETEXT))) {
3001 src = GlobalLock(hsrc);
3002 len = lstrlenW(src);
3003 /* Protect single-line edit against pasting new line character */
3004 if (!(es->style & ES_MULTILINE) && ((ptr = wcschr(src, '\n')))) {
3005 len = ptr - src;
3006 if (len && src[len - 1] == '\r')
3007 --len;
3008 }
3010 GlobalUnlock(hsrc);
3011 }
3012 else if (es->style & ES_PASSWORD) {
3013 /* clear selected text in password edit box even with empty clipboard */
3015 }
#define wcschr
Definition: compat.h:17
static PVOID ptr
Definition: dispmode.c:27
HANDLE WINAPI GetClipboardData(_In_ UINT)

Referenced by EDIT_WindowProc(), and EDIT_WM_KeyDown().

◆ EDIT_WM_SetFocus()

static void EDIT_WM_SetFocus ( HTHEME  theme,
EDITSTATE es 
)
static

Definition at line 3771 of file edit.c.

3773{
3775
3776 es->flags |= EF_FOCUSED;
3777
3778 if (!(es->style & ES_NOHIDESEL))
3779 EDIT_InvalidateText(es, es->selection_start, es->selection_end);
3780
3781#ifdef __REACTOS__
3782 SystemParametersInfo(SPI_GETCARETWIDTH, 0, &es->dwCaretWidth, 0);
3783 CreateCaret(es->hwndSelf, NULL, es->dwCaretWidth, es->line_height);
3784#else
3785 CreateCaret(es->hwndSelf, 0, 1, es->line_height);
3786#endif
3787 EDIT_SetCaretPos(es, es->selection_end, es->flags & EF_AFTER_WRAP);
3788 ShowCaret(es->hwndSelf);
3789 if (!notify_parent(es, EN_SETFOCUS)) return;
3790
3791 if (theme)
3793
3794 RedrawWindow(es->hwndSelf, NULL, NULL, flags);
BOOL WINAPI ShowCaret(_In_opt_ HWND)
#define EN_SETFOCUS
Definition: winuser.h:2030
#define RDW_ERASE
Definition: winuser.h:1214
BOOL WINAPI CreateCaret(_In_ HWND, _In_opt_ HBITMAP, _In_ int, _In_ int)
#define SystemParametersInfo
Definition: winuser.h:5870

Referenced by EDIT_WindowProc().

◆ EDIT_WM_SetFont()

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

Definition at line 3829 of file edit.c.

3831{
3833 HDC dc;
3834 HFONT old_font = 0;
3835 RECT clientRect;
3836 DWORD margins;
3837
3838 es->font = font;
3840 dc = GetDC(es->hwndSelf);
3841 if (font)
3842 old_font = SelectObject(dc, font);
3844 es->line_height = tm.tmHeight;
3845 es->char_width = tm.tmAveCharWidth;
3847 if (font)
3848 SelectObject(dc, old_font);
3849 ReleaseDC(es->hwndSelf, dc);
3850
3851 /* Reset the format rect and the margins */
3852 GetClientRect(es->hwndSelf, &clientRect);
3853 EDIT_SetRectNP(es, &clientRect);
3854 if (margins)
3857
3858 if (es->style & ES_MULTILINE)
3860 else
3862
3863 if (redraw)
3865 if (es->flags & EF_FOCUSED) {
3866 DestroyCaret();
3867#ifdef __REACTOS__
3868 CreateCaret(es->hwndSelf, NULL, es->dwCaretWidth, es->line_height);
3869#else
3870 CreateCaret(es->hwndSelf, 0, 1, es->line_height);
3871#endif
3872 EDIT_SetCaretPos(es, es->selection_end,
3873 es->flags & EF_AFTER_WRAP);
3874 ShowCaret(es->hwndSelf);
3875 }
3876#ifdef __REACTOS__
3878 {
3879 LOGFONTW lf;
3880 HIMC hIMC = ImmGetContext(es->hwndSelf);
3881 if (font == NULL)
3883 GetObjectW(font, sizeof(lf), &lf);
3884 ImmSetCompositionFontW(hIMC, &lf);
3885 ImmReleaseContext(es->hwndSelf, hIMC);
3886 }
3887#endif
static RECT margins
Definition: print.c:55
static DWORD get_font_margins(HDC hdc, const TEXTMETRICW *tm)
Definition: edit.c:3797
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

Referenced by EDIT_WindowProc(), and EDIT_WM_Create().

◆ EDIT_WM_SetText()

static void EDIT_WM_SetText ( EDITSTATE es,
LPCWSTR  text 
)
static

Definition at line 3902 of file edit.c.

3904{
3905 if (es->flags & EF_UPDATE)
3906 /* fixed this bug once; complain if we see it about to happen again. */
3907 ERR("SetSel may generate UPDATE message whose handler may reset "
3908 "selection.\n");
3909
3910 EDIT_EM_SetSel(es, 0, (UINT)-1, FALSE);
3911 if (text)
3912 {
3913 TRACE("%s\n", debugstr_w(text));
3915 }
3916 else
3917 {
3918 TRACE("<NULL>\n");
3920 }
3921 es->x_offset = 0;
3922 es->flags &= ~EF_MODIFIED;
3923 EDIT_EM_SetSel(es, 0, 0, FALSE);
3924
3925 /* Send the notification after the selection start and end have been set
3926 * edit control doesn't send notification on WM_SETTEXT
3927 * if it is multiline, or it is part of combobox
3928 */
3929 if( !((es->style & ES_MULTILINE) || es->hwndListBox))
3930 {
3931 if (!notify_parent(es, EN_UPDATE)) return;
3932 if (!notify_parent(es, EN_CHANGE)) return;
3933 }

Referenced by EDIT_WindowProc().

◆ EDIT_WM_Size()

static void EDIT_WM_Size ( EDITSTATE es,
UINT  action 
)
static

Definition at line 3944 of file edit.c.

3946{
3947 if ((action == SIZE_MAXIMIZED) || (action == SIZE_RESTORED)) {
3948 RECT rc;
3949 GetClientRect(es->hwndSelf, &rc);
3950 EDIT_SetRectNP(es, &rc);
3952 }
#define SIZE_MAXIMIZED
Definition: winuser.h:2510
#define SIZE_RESTORED
Definition: winuser.h:2508

Referenced by EDIT_WindowProc().

◆ EDIT_WM_StyleChanged()

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

Definition at line 3977 of file edit.c.

3979{
3980 if (GWL_STYLE == which) {
3981 DWORD style_change_mask;
3982 DWORD new_style;
3983 /* Only a subset of changes can be applied after the control
3984 * has been created.
3985 */
3986 style_change_mask = ES_UPPERCASE | ES_LOWERCASE |
3987 ES_NUMBER;
3988 if (es->style & ES_MULTILINE)
3989 style_change_mask |= ES_WANTRETURN;
3990
3991 new_style = style->styleNew & style_change_mask;
3992
3993 /* Number overrides lowercase overrides uppercase (at least it
3994 * does in Win95). However I'll bet that ES_NUMBER would be
3995 * invalid under Win 3.1.
3996 */
3997 if (new_style & ES_NUMBER) {
3998 ; /* do not override the ES_NUMBER */
3999 } else if (new_style & ES_LOWERCASE) {
4000 new_style &= ~ES_UPPERCASE;
4001 }
4002
4003 es->style = (es->style & ~style_change_mask) | new_style;
4004 } else if (GWL_EXSTYLE == which) {
4005 ; /* FIXME - what is needed here */
4006 } else {
4007 WARN ("Invalid style change %ld\n",which);
4008 }
4009
4010 return 0;
static GLenum which
Definition: wgl_font.c:159

Referenced by EDIT_WindowProc().

◆ EDIT_WM_SysKeyDown()

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

Definition at line 4017 of file edit.c.

4019{
4020 if ((key == VK_BACK) && (key_data & 0x2000)) {
4021 if (EDIT_EM_CanUndo(es))
4023 return 0;
4024 } else if (key == VK_UP || key == VK_DOWN) {
4026 return 0;
4027 }
4028 return DefWindowProcW(es->hwndSelf, WM_SYSKEYDOWN, key, key_data);

Referenced by EDIT_WindowProc().

◆ EDIT_WM_Timer()

static void EDIT_WM_Timer ( EDITSTATE es)
static

Definition at line 4036 of file edit.c.

4038{
4039 if (es->region_posx < 0) {
4041 } else if (es->region_posx > 0) {
4043 }
4044/*
4045 * FIXME: gotta do some vertical scrolling here, like
4046 * EDIT_EM_LineScroll(hwnd, 0, 1);
4047 */

Referenced by EDIT_WindowProc().

◆ EDIT_WM_VScroll()

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

Definition at line 4186 of file edit.c.

4188{
4189 INT dy;
4190
4191 if (!(es->style & ES_MULTILINE))
4192 return 0;
4193
4194 if (!(es->style & ES_AUTOVSCROLL))
4195 return 0;
4196
4197 dy = 0;
4198 switch (action) {
4199 case SB_LINEUP:
4200 case SB_LINEDOWN:
4201 case SB_PAGEUP:
4202 case SB_PAGEDOWN:
4203 TRACE("action %d (%s)\n", action, (action == SB_LINEUP ? "SB_LINEUP" :
4204 (action == SB_LINEDOWN ? "SB_LINEDOWN" :
4205 (action == SB_PAGEUP ? "SB_PAGEUP" :
4206 "SB_PAGEDOWN"))));
4208 return 0;
4209 case SB_TOP:
4210 TRACE("SB_TOP\n");
4211 dy = -es->y_offset;
4212 break;
4213 case SB_BOTTOM:
4214 TRACE("SB_BOTTOM\n");
4215 dy = es->line_count - 1 - es->y_offset;
4216 break;
4217 case SB_THUMBTRACK:
4218 TRACE("SB_THUMBTRACK %d\n", pos);
4219 es->flags |= EF_VSCROLL_TRACK;
4220 if(es->style & WS_VSCROLL)
4221 dy = pos - es->y_offset;
4222 else
4223 {
4224 /* Assume default scroll range 0-100 */
4225 INT vlc, new_y;
4226 /* Sanity check */
4227 if(pos < 0 || pos > 100) return 0;
4229 new_y = pos * (es->line_count - vlc) / 100;
4230 dy = es->line_count ? (new_y - es->y_offset) : 0;
4231 TRACE("line_count=%d, y_offset=%d, pos=%d, dy = %d\n",
4232 es->line_count, es->y_offset, pos, dy);
4233 }
4234 break;
4235 case SB_THUMBPOSITION:
4236 TRACE("SB_THUMBPOSITION %d\n", pos);
4237 es->flags &= ~EF_VSCROLL_TRACK;
4238 if(es->style & WS_VSCROLL)
4239 dy = pos - es->y_offset;
4240 else
4241 {
4242 /* Assume default scroll range 0-100 */
4243 INT vlc, new_y;
4244 /* Sanity check */
4245 if(pos < 0 || pos > 100) return 0;
4247 new_y = pos * (es->line_count - vlc) / 100;
4248 dy = es->line_count ? (new_y - es->y_offset) : 0;
4249 TRACE("line_count=%d, y_offset=%d, pos=%d, dy = %d\n",
4250 es->line_count, es->y_offset, pos, dy);
4251 }
4252 if (!dy)
4253 {
4254 /* force scroll info update */
4257 }
4258 break;
4259 case SB_ENDSCROLL:
4260 TRACE("SB_ENDSCROLL\n");
4261 break;
4262 /*
4263 * FIXME : the next two are undocumented !
4264 * Are we doing the right thing ?
4265 * At least Win 3.1 Notepad makes use of EM_GETTHUMB this way,
4266 * although it's also a regular control message.
4267 */
4268 case EM_GETTHUMB: /* this one is used by NT notepad */
4269 {
4270 LRESULT ret;
4271 if(GetWindowLongW( es->hwndSelf, GWL_STYLE ) & WS_VSCROLL)
4272 ret = GetScrollPos(es->hwndSelf, SB_VERT);
4273 else
4274 {
4275 /* Assume default scroll range 0-100 */
4277 ret = es->line_count ? es->y_offset * 100 / (es->line_count - vlc) : 0;
4278 }
4279 TRACE("EM_GETTHUMB: returning %ld\n", ret);
4280 return ret;
4281 }
4282 case EM_LINESCROLL:
4283 TRACE("EM_LINESCROLL %d\n", pos);
4284 dy = pos;
4285 break;
4286
4287 default:
4288 ERR("undocumented WM_VSCROLL action %d (0x%04x), please report\n",
4289 action, action);
4290 return 0;
4291 }
4292 if (dy)
4294 return 0;
#define SB_BOTTOM
Definition: winuser.h:577
#define SB_TOP
Definition: winuser.h:578

Referenced by EDIT_EM_GetThumb(), and EDIT_WindowProc().

◆ EDIT_WordBreakProc()

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

Definition at line 236 of file edit.c.

238{
239 INT ret = 0;
240
241 TRACE("s=%p, index=%d, count=%d, action=%d\n", s, index, count, action);
242
243 if(!s) return 0;
244
245 if (!es->logAttr)
246 {
248
249 memset(&psa,0,sizeof(SCRIPT_ANALYSIS));
250 psa.eScript = SCRIPT_UNDEFINED;
251
252 es->logAttr = heap_alloc(sizeof(SCRIPT_LOGATTR) * get_text_length(es));
253 ScriptBreak(es->text, get_text_length(es), &psa, es->logAttr);
254 }
255
256 switch (action) {
257 case WB_LEFT:
258 if (index)
259 index--;
260 while (index && !es->logAttr[index].fSoftBreak)
261 index--;
262 ret = index;
263 break;
264 case WB_RIGHT:
265 if (!count)
266 break;
267 while (index < count && s[index] && !es->logAttr[index].fSoftBreak)
268 index++;
269 ret = index;
270 break;
271 case WB_ISDELIMITER:
272 ret = es->logAttr[index].fWhiteSpace;
273 break;
274 default:
275 ERR("unknown action code, please report !\n");
276 break;
277 }
278 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 SCRIPT_UNDEFINED
Definition: usp10.h:69
#define WB_ISDELIMITER
Definition: winuser.h:549

Referenced by EDIT_CallWordBreakProc().

◆ get_cjk_fontinfo_margin()

static int get_cjk_fontinfo_margin ( int  width,
int  side_bearing 
)
static

Definition at line 2765 of file edit.c.

2767{
2768 int margin;
2769 if (side_bearing < 0)
2770 margin = min(-side_bearing, width/2);
2771 else
2772 margin = 0;
2773 return margin;

Referenced by EDIT_EM_SetMargins(), and test_margins_default().

◆ get_font_margins()

static DWORD get_font_margins ( HDC  hdc,
const TEXTMETRICW tm 
)
static

Definition at line 3797 of file edit.c.

3799{
3800 ABC abc[256];
3801 SHORT left, right;
3802 UINT i;
3803
3804 if (!(tm->tmPitchAndFamily & (TMPF_VECTOR | TMPF_TRUETYPE)))
3806
3807 if (!is_cjk(hdc))
3809
3810 if (!GetCharABCWidthsW(hdc, 0, 255, abc))
3811 return 0;
3812
3813 left = right = 0;
3814 for (i = 0; i < ARRAY_SIZE(abc); i++) {
3815 if (-abc[i].abcA > right) right = -abc[i].abcA;
3816 if (-abc[i].abcC > left ) left = -abc[i].abcC;
3817 }
3818 return MAKELONG(left, right);
#define ARRAY_SIZE(A)
Definition: main.h:20
static UINT UINT LPWORD LPABC abc
Definition: font.c:44
short SHORT
Definition: pedump.c:59
Definition: wingdi.h:1410
int abcA
Definition: wingdi.h:1411
int abcC
Definition: wingdi.h:1413
BOOL WINAPI GetCharABCWidthsW(_In_ HDC hdc, _In_ UINT wFirst, _In_ UINT wLast, _Out_writes_(wLast - wFirst+1) LPABC lpABC)

Referenced by EDIT_WM_SetFont().

◆ get_text_length()

◆ get_vertical_line_count()

static INT get_vertical_line_count ( EDITSTATE es)
inlinestatic

Definition at line 414 of file edit.c.

416{
417 INT vlc = (es->format_rect.bottom - es->format_rect.top) / es->line_height;
418 return max(1,vlc);

Referenced by EDIT_AdjustFormatRect(), EDIT_BuildLineDefs_ML(), EDIT_EM_ReplaceSel(), EDIT_EM_Scroll(), EDIT_EM_ScrollCaret(), EDIT_ML_InvalidateText(), EDIT_PaintLine(), EDIT_WM_Paint(), and EDIT_WM_VScroll().

◆ GetCharWidthInfo()

BOOL WINAPI GetCharWidthInfo ( HDC  ,
struct char_width_info  
)

Referenced by EDIT_EM_SetMargins().

◆ heap_strdupW()

static WCHAR * heap_strdupW ( const WCHAR str)
inlinestatic

Definition at line 4312 of file edit.c.

4314{
4315 int len = lstrlenW(str) + 1;
4316 WCHAR *ret = heap_alloc(len * sizeof(WCHAR));
4317 lstrcpyW(ret, str);
4318 return ret;
const WCHAR * str

Referenced by add_prop(), alloc_global_prop(), alloc_prop(), alloc_vbscode(), APPINFO_SetOption(), BPInternetProtocolSink_ReportProgress(), BPInternetProtocolSink_ReportResult(), cache_authorization(), cache_basic_authorization(), cache_containers_add(), cache_file_available(), create_channelbsc(), create_class_object(), create_req_file(), create_signature_columns_and_data(), create_table(), dispid_from_elem_name(), DownloadBSC_Create(), DownloadBSC_OnProgress(), EDIT_EM_SetCueBanner(), fill_cdromdrive(), fill_diskdrive(), fill_diskpartition(), fill_logicaldisk(), fill_networkadapter(), fill_networkadapterconfig(), fill_operatingsystem(), fill_pnpentity(), fill_printer(), fill_process(), fill_processor(), fill_service(), fill_sid(), fill_videocontroller(), fix_url_value(), FTP_Connect(), FTP_FtpOpenFileW(), FtpCreateDirectoryW(), FtpDeleteFileW(), FtpFindFirstFileW(), FtpGetFileW(), FtpOpenFileW(), FtpPutFileW(), FtpRemoveDirectoryW(), FtpRenameFileW(), FtpSetCurrentDirectoryW(), get_accountname(), get_baseboard_manufacturer(), get_baseboard_product(), get_baseboard_serialnumber(), get_baseboard_version(), get_bios_manufacturer(), get_bios_releasedate(), get_bios_smbiosbiosversion(), get_cmdline(), get_compsysproduct_identifyingnumber(), get_compsysproduct_name(), get_compsysproduct_uuid(), get_compsysproduct_vendor(), get_compsysproduct_version(), get_defaultipgateway(), get_diskdrivetodiskpartition_pairs(), get_dnshostname(), get_dnsserversearchorder(), get_dynamic_prop(), get_filesystem(), get_host_header(), get_ipaddress(), get_ipsubnet(), get_logicaldisktopartition_pairs(), get_referenceddomainname(), get_settingid(), get_systemenclosure_manufacturer(), get_useragent(), get_volumename(), get_volumeserialnumber(), HTMLDOMAttribute_Create(), HTMLElement_clone(), HTMLStyle_put_filter(), HTTP_Connect(), HTTP_DoAuthorization(), HTTP_FixURL(), HTTP_GetResponseHeaders(), HTTP_HttpEndRequestW(), HTTP_HttpOpenRequestW(), HTTP_HttpSendRequestW(), HTTP_InsertCustomHeader(), HTTP_ProcessCookies(), HTTPREQ_SetOption(), HTTPSESSION_SetOption(), init_code(), INTERNET_LoadProxySettings(), INTERNET_SendCallback(), InternetOpenUrlW(), InternetOpenW(), InternetProtocolSink_ReportProgress(), InternetSession_RegisterMimeFilter(), InternetSetOptionW(), is_basic_auth_value(), JScript_AddNamedItem(), MetadataQueryReader_CreateInstance(), mime_available(), MonikerProp_PutProperty(), parse_event_elem(), parse_proxy_url(), ProtocolSinkHandler_ReportData(), query_global_option(), register_namespace(), retrieve_cached_authorization(), set_dochost_url(), to_array(), to_longlong(), update_travellog(), VBScript_AddNamedItem(), wbem_services_ExecNotificationQueryAsync(), wbem_services_ExecQueryAsync(), WbemQualifierSet_create(), WbemServices_create(), and WININET_SetAuthorization().

◆ is_cjk()

static BOOL is_cjk ( HDC  dc)
static

Definition at line 2751 of file edit.c.

2753{
2756
2757 switch (GdiGetCodePage(dc)) {
2758 case 932: case 936: case 949: case 950: case 1361:
2759 return TRUE;
2760 default:
2761 return (GetTextCharsetInfo(dc, &fs, 0) != DEFAULT_CHARSET &&
2762 (fs.fsCsb[0] & FS_DBCS_MASK));
2763 }
#define fs
Definition: i386-dis.c:444
Definition: ffs.h:70
#define FS_JOHAB
Definition: wingdi.h:574
int WINAPI GetTextCharsetInfo(_In_ HDC, _Out_opt_ LPFONTSIGNATURE, _In_ DWORD)
#define FS_WANSUNG
Definition: wingdi.h:572
#define DEFAULT_CHARSET
Definition: wingdi.h:384
#define FS_JISJAPAN
Definition: wingdi.h:570
#define FS_CHINESETRAD
Definition: wingdi.h:573
#define FS_CHINESESIMP
Definition: wingdi.h:571
DWORD WINAPI GdiGetCodePage(HDC)

◆ notify_parent()

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

Definition at line 166 of file edit.c.

168{
169 HWND hwnd = es->hwndSelf;
170 TRACE("notification %d sent to %p.\n", code, es->hwndParent);
171 SendMessageW(es->hwndParent, WM_COMMAND, MAKEWPARAM(GetWindowLongPtrW(es->hwndSelf, GWLP_ID), code), (LPARAM)es->hwndSelf);
172 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

Referenced by EDIT_EM_LineScroll_internal(), EDIT_EM_ReplaceSel(), EDIT_EM_Undo(), EDIT_MakeFit(), EDIT_UpdateText(), EDIT_UpdateTextRegion(), EDIT_WM_HScroll(), EDIT_WM_KeyDown(), EDIT_WM_KillFocus(), EDIT_WM_SetFocus(), EDIT_WM_SetText(), and EDIT_WM_VScroll().

◆ text_buffer_changed()

static void text_buffer_changed ( EDITSTATE es)
inlinestatic

Definition at line 1198 of file edit.c.

1200{
1201 es->text_length = (UINT)-1;
1202
1203 heap_free( es->logAttr );
1204 es->logAttr = NULL;

Referenced by EDIT_EM_ReplaceSel(), and EDIT_EM_SetHandle().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( edit  )