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

Go to the source code of this file.

Classes

struct  tagLINEDEF
 
struct  EDITSTATE
 
struct  char_width_info
 

Macros

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

Typedefs

typedef struct tagLINEDEF LINEDEF
 

Enumerations

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

Functions

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

Macro Definition Documentation

◆ BUFLIMIT_INITIAL

#define BUFLIMIT_INITIAL   30000 /* initial buffer size */

Definition at line 57 of file edit.c.

◆ EF_AFTER_WRAP

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

Definition at line 70 of file edit.c.

◆ EF_DIALOGMODE

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

Definition at line 72 of file edit.c.

◆ EF_FOCUSED

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

Definition at line 66 of file edit.c.

◆ EF_HSCROLL_TRACK

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

Definition at line 69 of file edit.c.

◆ EF_MODIFIED

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

Definition at line 65 of file edit.c.

◆ EF_UPDATE

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

Definition at line 67 of file edit.c.

◆ EF_USE_SOFTBRK

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

Definition at line 71 of file edit.c.

◆ EF_VSCROLL_TRACK

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

Definition at line 68 of file edit.c.

◆ GROWLENGTH

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

Definition at line 58 of file edit.c.

◆ HSCROLL_FRACTION

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

Definition at line 60 of file edit.c.

◆ ID_CB_LISTBOX

#define ID_CB_LISTBOX   1000

Definition at line 74 of file edit.c.

◆ ORDER_UINT

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

Definition at line 164 of file edit.c.

◆ ROUND_TO_GROW

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

Definition at line 59 of file edit.c.

◆ SWAP_UINT32

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

Definition at line 163 of file edit.c.

Typedef Documentation

◆ LINEDEF

typedef struct tagLINEDEF LINEDEF

Enumeration Type Documentation

◆ LINE_END

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

Definition at line 76 of file edit.c.

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

Function Documentation

◆ EDIT_AdjustFormatRect()

static void EDIT_AdjustFormatRect ( EDITSTATE *  es)
static

Definition at line 2268 of file edit.c.

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

Referenced by EDIT_EM_SetMargins(), and EDIT_SetRectNP().

◆ EDIT_BuildLineDefs_ML()

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

Definition at line 429 of file edit.c.

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

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

◆ EDIT_CalcLineWidth_SL()

static void EDIT_CalcLineWidth_SL ( EDITSTATE *  es)
static

Definition at line 761 of file edit.c.

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

Referenced by EDIT_EM_ReplaceSel(), and EDIT_WM_SetFont().

◆ EDIT_CallWordBreakProc()

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

Definition at line 294 of file edit.c.

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

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

◆ EDIT_CharFromPos()

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

Definition at line 784 of file edit.c.

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

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

◆ EDIT_CheckCombo()

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

Definition at line 3281 of file edit.c.

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

Referenced by EDIT_WM_KeyDown(), and EDIT_WM_SysKeyDown().

◆ EDIT_ConfinePoint()

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

Definition at line 901 of file edit.c.

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

Referenced by EDIT_WM_LButtonDown(), and EDIT_WM_MouseMove().

◆ EDIT_ContextMenuCommand()

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

Definition at line 3167 of file edit.c.

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

Referenced by EDIT_WM_ContextMenu().

◆ EDIT_EM_CanUndo()

static BOOL EDIT_EM_CanUndo ( const EDITSTATE *  es)
inlinestatic

Definition at line 181 of file edit.c.

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

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

◆ EDIT_EM_CharFromPos()

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

Definition at line 2363 of file edit.c.

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

Referenced by EDIT_WindowProc().

◆ EDIT_EM_EmptyUndoBuffer()

static void EDIT_EM_EmptyUndoBuffer ( EDITSTATE *  es)
inlinestatic

Definition at line 192 of file edit.c.

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

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

◆ EDIT_EM_FmtLines()

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

Definition at line 2391 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetCueBanner()

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

Definition at line 4342 of file edit.c.

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

Referenced by EDIT_WindowProc().

◆ EDIT_EM_GetHandle()

static HLOCAL EDIT_EM_GetHandle ( EDITSTATE *  es)
static

Definition at line 2413 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetLine()

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

Definition at line 2433 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetSel()

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

Definition at line 2471 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_GetThumb()

static LRESULT EDIT_EM_GetThumb ( EDITSTATE *  es)
static

Definition at line 4306 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_LineFromChar()

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

Definition at line 913 of file edit.c.

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

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

◆ EDIT_EM_LineIndex()

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

Definition at line 942 of file edit.c.

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

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

◆ EDIT_EM_LineLength()

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

Definition at line 977 of file edit.c.

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

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

◆ EDIT_EM_LineScroll()

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

Definition at line 1657 of file edit.c.

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

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

◆ EDIT_EM_LineScroll_internal()

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

Definition at line 1601 of file edit.c.

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

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

◆ EDIT_EM_PosFromChar()

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

Definition at line 1013 of file edit.c.

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

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

◆ EDIT_EM_ReplaceSel()

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

Definition at line 2492 of file edit.c.

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

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

◆ EDIT_EM_Scroll()

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

Definition at line 1672 of file edit.c.

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

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

◆ EDIT_EM_ScrollCaret()

static void EDIT_EM_ScrollCaret ( EDITSTATE *  es)
static

Definition at line 1780 of file edit.c.

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

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

◆ EDIT_EM_SetCueBanner()

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

Definition at line 4325 of file edit.c.

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

Referenced by EDIT_WindowProc().

◆ EDIT_EM_SetHandle()

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

Definition at line 2705 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetLimitText()

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

Definition at line 2744 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetMargins()

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

Definition at line 2794 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EDIT_WM_SetFont().

◆ EDIT_EM_SetPasswordChar()

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

Definition at line 2866 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetSel()

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

Definition at line 1489 of file edit.c.

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

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

◆ EDIT_EM_SetTabStops()

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

Definition at line 2895 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_SetWordBreakProc()

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

Definition at line 2917 of file edit.c.

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

Referenced by EDIT_WindowProc(), and EditWndProc_common().

◆ EDIT_EM_Undo()

static BOOL EDIT_EM_Undo ( EDITSTATE *  es)
static

Definition at line 2936 of file edit.c.

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

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

◆ EDIT_GetCompositionStr()

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

Definition at line 4367 of file edit.c.

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

Referenced by EDIT_ImeComposition().

◆ EDIT_GetLineRect()

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

Definition at line 1147 of file edit.c.

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

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

◆ EDIT_GetResultStr()

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

Definition at line 4438 of file edit.c.

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

Referenced by EDIT_ImeComposition().

◆ EDIT_ImeComposition()

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

Definition at line 4473 of file edit.c.

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

Referenced by EDIT_WindowProc().

◆ EDIT_InvalidateText()

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

Definition at line 1459 of file edit.c.

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

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

◆ EDIT_InvalidateUniscribeData()

static void EDIT_InvalidateUniscribeData ( EDITSTATE *  es)
inlinestatic

Definition at line 315 of file edit.c.

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

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

◆ EDIT_InvalidateUniscribeData_linedef()

static void EDIT_InvalidateUniscribeData_linedef ( LINEDEF *  line_def)
inlinestatic

Definition at line 306 of file edit.c.

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

Referenced by EDIT_BuildLineDefs_ML(), and EDIT_InvalidateUniscribeData().

◆ EDIT_IsInsideDialog()

static BOOL EDIT_IsInsideDialog ( EDITSTATE *  es)
inlinestatic

Definition at line 2977 of file edit.c.

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

Referenced by EDIT_WM_Char(), and EDIT_WM_KeyDown().

◆ EDIT_LockBuffer()

static void EDIT_LockBuffer ( EDITSTATE *  es)
static

Definition at line 1211 of file edit.c.

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

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

◆ EDIT_MakeFit()

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

Definition at line 1276 of file edit.c.

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

Referenced by EDIT_EM_ReplaceSel().

◆ EDIT_MakeUndoFit()

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

Definition at line 1317 of file edit.c.

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

Referenced by EDIT_EM_ReplaceSel().

◆ EDIT_ML_InvalidateText()

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

Definition at line 1394 of file edit.c.

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

Referenced by EDIT_InvalidateText().

◆ EDIT_MoveBackward()

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

Definition at line 1849 of file edit.c.

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

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

◆ EDIT_MoveDown_ML()

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

Definition at line 1876 of file edit.c.

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

Referenced by EDIT_WM_Char(), and EDIT_WM_KeyDown().

◆ EDIT_MoveEnd()

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

Definition at line 1898 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveForward()

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

Definition at line 1919 of file edit.c.

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

Referenced by EDIT_WM_KeyDown(), and EDIT_WM_Timer().

◆ EDIT_MoveHome()

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

Definition at line 1944 of file edit.c.

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

Referenced by EDIT_WM_Char(), and EDIT_WM_KeyDown().

◆ EDIT_MovePageDown_ML()

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

Definition at line 1968 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MovePageUp_ML()

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

Definition at line 1996 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveUp_ML()

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

Definition at line 2024 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveWordBackward()

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

Definition at line 2046 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_MoveWordForward()

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

Definition at line 2077 of file edit.c.

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

Referenced by EDIT_WM_KeyDown().

◆ EDIT_NotifyCtlColor()

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

Definition at line 198 of file edit.c.

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

Referenced by EDIT_WM_Paint().

◆ EDIT_PaintLine()

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

Definition at line 2181 of file edit.c.

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

Referenced by EDIT_WM_Paint().

◆ EDIT_PaintText()

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

Definition at line 2107 of file edit.c.

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

Referenced by EDIT_PaintLine().

◆ EDIT_Register()

void EDIT_Register ( void  )

Definition at line 5279 of file edit.c.

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

Referenced by DllMain().

◆ EDIT_SetCaretPos()

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

Definition at line 1750 of file edit.c.

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

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

◆ EDIT_SetRectNP()

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

Definition at line 2319 of file edit.c.

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

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

◆ EDIT_SL_InvalidateText()

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

Definition at line 1376 of file edit.c.

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

Referenced by EDIT_InvalidateText().

◆ EDIT_UnlockBuffer()

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

Definition at line 1230 of file edit.c.

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

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

◆ EDIT_UpdateScrollInfo()

static void EDIT_UpdateScrollInfo ( EDITSTATE *  es)
static

Definition at line 1560 of file edit.c.

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

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

◆ EDIT_UpdateText()

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

Definition at line 1359 of file edit.c.

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

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

◆ EDIT_UpdateTextRegion()

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

Definition at line 1344 of file edit.c.

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

Referenced by EDIT_EM_ReplaceSel().

◆ EDIT_UpdateUniscribeData()

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

Definition at line 372 of file edit.c.

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

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

◆ EDIT_UpdateUniscribeData_linedef()

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

Definition at line 330 of file edit.c.

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

Referenced by EDIT_BuildLineDefs_ML(), and EDIT_UpdateUniscribeData().

◆ EDIT_WindowProc()

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

Definition at line 4717 of file edit.c.

4719{
4720 EDITSTATE *es = (EDITSTATE *)GetWindowLongPtrW(hwnd, 0);
4721 HTHEME theme = GetWindowTheme(hwnd);
4722 LRESULT result = 0;
4723 RECT *rect;
4724
4725 TRACE("hwnd=%p msg=%#x wparam=%lx lparam=%lx\n", hwnd, msg, wParam, lParam);
4726
4727 if (!es && msg != WM_NCCREATE)
4728 return DefWindowProcW(hwnd, msg, wParam, lParam);
4729
4730 if (es && (msg != WM_NCDESTROY))
4731 EDIT_LockBuffer(es);
4732
4733 switch (msg)
4734 {
4735 case EM_GETSEL:
4736 result = EDIT_EM_GetSel(es, (UINT *)wParam, (UINT *)lParam);
4737 break;
4738
4739 case EM_SETSEL:
4740 EDIT_EM_SetSel(es, wParam, lParam, FALSE);
4741 EDIT_EM_ScrollCaret(es);
4742 result = 1;
4743 break;
4744
4745 case EM_GETRECT:
4746 rect = (RECT *)lParam;
4747 if (rect)
4748 *rect = es->format_rect;
4749 break;
4750
4751 case EM_SETRECT:
4752 if ((es->style & ES_MULTILINE) && lParam)
4753 {
4754 EDIT_SetRectNP(es, (RECT *)lParam);
4755 EDIT_UpdateText(es, NULL, TRUE);
4756 }
4757 break;
4758
4759 case EM_SETRECTNP:
4760 if ((es->style & ES_MULTILINE) && lParam)
4761 EDIT_SetRectNP(es, (LPRECT)lParam);
4762 break;
4763
4764 case EM_SCROLL:
4765 result = EDIT_EM_Scroll(es, (INT)wParam);
4766 break;
4767
4768 case EM_LINESCROLL:
4769 result = (LRESULT)EDIT_EM_LineScroll(es, (INT)wParam, (INT)lParam);
4770 break;
4771
4772 case EM_SCROLLCARET:
4773 EDIT_EM_ScrollCaret(es);
4774 result = 1;
4775 break;
4776
4777 case EM_GETMODIFY:
4778 result = ((es->flags & EF_MODIFIED) != 0);
4779 break;
4780
4781 case EM_SETMODIFY:
4782 if (wParam)
4783 es->flags |= EF_MODIFIED;
4784 else
4785 es->flags &= ~(EF_MODIFIED | EF_UPDATE); /* reset pending updates */
4786 break;
4787
4788 case EM_GETLINECOUNT:
4789 result = (es->style & ES_MULTILINE) ? es->line_count : 1;
4790 break;
4791
4792 case EM_LINEINDEX:
4793 result = (LRESULT)EDIT_EM_LineIndex(es, (INT)wParam);
4794 break;
4795
4796 case EM_SETHANDLE:
4797 EDIT_EM_SetHandle(es, (HLOCAL)wParam);
4798 break;
4799
4800 case EM_GETHANDLE:
4801 result = (LRESULT)EDIT_EM_GetHandle(es);
4802 break;
4803
4804 case EM_GETTHUMB:
4805 result = EDIT_EM_GetThumb(es);
4806 break;
4807
4808 /* these messages missing from specs */
4809 case 0x00bf:
4810 case 0x00c0:
4811 case 0x00c3:
4812 case 0x00ca:
4813 FIXME("undocumented message 0x%x, please report\n", msg);
4814 result = DefWindowProcW(hwnd, msg, wParam, lParam);
4815 break;
4816
4817 case EM_LINELENGTH:
4818 result = (LRESULT)EDIT_EM_LineLength(es, (INT)wParam);
4819 break;
4820
4821 case EM_REPLACESEL:
4822 {
4823 const WCHAR *textW = (const WCHAR *)lParam;
4824
4825 EDIT_EM_ReplaceSel(es, (BOOL)wParam, textW, lstrlenW(textW), TRUE, TRUE);
4826 result = 1;
4827 break;
4828 }
4829
4830 case EM_GETLINE:
4831 result = (LRESULT)EDIT_EM_GetLine(es, (INT)wParam, (LPWSTR)lParam);
4832 break;
4833
4834 case EM_SETLIMITTEXT:
4835 EDIT_EM_SetLimitText(es, wParam);
4836 break;
4837
4838 case EM_CANUNDO:
4839 result = (LRESULT)EDIT_EM_CanUndo(es);
4840 break;
4841
4842 case EM_UNDO:
4843 case WM_UNDO:
4844 result = (LRESULT)EDIT_EM_Undo(es);
4845 break;
4846
4847 case EM_FMTLINES:
4848 result = (LRESULT)EDIT_EM_FmtLines(es, (BOOL)wParam);
4849 break;
4850
4851 case EM_LINEFROMCHAR:
4852 result = (LRESULT)EDIT_EM_LineFromChar(es, (INT)wParam);
4853 break;
4854
4855 case EM_SETTABSTOPS:
4856 result = (LRESULT)EDIT_EM_SetTabStops(es, (INT)wParam, (LPINT)lParam);
4857 break;
4858
4859 case EM_SETPASSWORDCHAR:
4860 EDIT_EM_SetPasswordChar(es, wParam);
4861 break;
4862
4863 case EM_EMPTYUNDOBUFFER:
4864 EDIT_EM_EmptyUndoBuffer(es);
4865 break;
4866
4867 case EM_GETFIRSTVISIBLELINE:
4868 result = (es->style & ES_MULTILINE) ? es->y_offset : es->x_offset;
4869 break;
4870
4871 case EM_SETREADONLY:
4872 {
4873 DWORD old_style = es->style;
4874
4875 if (wParam)
4876 {
4877 SetWindowLongW(hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE) | ES_READONLY);
4878 es->style |= ES_READONLY;
4879 }
4880 else
4881 {
4882 SetWindowLongW(hwnd, GWL_STYLE, GetWindowLongW(hwnd, GWL_STYLE) & ~ES_READONLY);
4883 es->style &= ~ES_READONLY;
4884 }
4885
4886 if (old_style ^ es->style)
4887 InvalidateRect(es->hwndSelf, NULL, TRUE);
4888
4889 result = 1;
4890 break;
4891 }
4892
4893 case EM_SETWORDBREAKPROC:
4894 EDIT_EM_SetWordBreakProc(es, (void *)lParam);
4895 result = 1;
4896 break;
4897
4898 case EM_GETWORDBREAKPROC:
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:
4907 EDIT_EM_SetMargins(es, (INT)wParam, LOWORD(lParam), HIWORD(lParam), TRUE);
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;
4920 else result = EDIT_EM_PosFromChar(es, (INT)wParam, FALSE);
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:
4928 result = EDIT_EM_SetCueBanner(es, (BOOL)wParam, (const WCHAR *)lParam);
4929 break;
4930
4931 case EM_GETCUEBANNER:
4932 result = EDIT_EM_GetCueBanner(es, (WCHAR *)wParam, (DWORD)lParam);
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:
4940 result = EDIT_WM_NCCreate(hwnd, (LPCREATESTRUCTW)lParam);
4941 break;
4942
4943 case WM_NCDESTROY:
4944 result = EDIT_WM_NCDestroy(es);
4945 es = NULL;
4946 break;
4947
4948 case WM_GETDLGCODE:
4949 result = DLGC_HASSETSEL | DLGC_WANTCHARS | DLGC_WANTARROWS;
4950
4951 if (es->style & ES_MULTILINE)
4952 result |= DLGC_WANTALLKEYS;
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)
4966 if (SendMessageW(GetParent(hwnd), CB_GETDROPPEDSTATE, 0, 0))
4967 result |= DLGC_WANTMESSAGE;
4968 }
4969 }
4970 }
4971 break;
4972
4973 case WM_IME_CHAR:
4974#ifdef __REACTOS__
4975 result = DefWindowProcW(hwnd, msg, wParam, lParam);
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 {
4986 if (SendMessageW(GetParent(hwnd), CB_GETDROPPEDSTATE, 0, 0))
4987 SendMessageW(GetParent(hwnd), WM_KEYDOWN, charW, 0);
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
5006 EDIT_WM_Char(es, wParam);
5007 }
5008 return 0;
5009
5010 case WM_CLEAR:
5011 EDIT_WM_Clear(es);
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:
5019 EDIT_WM_Copy(es);
5020 break;
5021
5022 case WM_CREATE:
5023 result = EDIT_WM_Create(es, ((LPCREATESTRUCTW)lParam)->lpszName);
5024 break;
5025
5026 case WM_CUT:
5027 EDIT_WM_Cut(es);
5028 break;
5029
5030 case WM_ENABLE:
5031 es->bEnableState = (BOOL) wParam;
5032 EDIT_UpdateText(es, NULL, TRUE);
5033 if (theme)
5034 RedrawWindow(hwnd, NULL, NULL, RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW);
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:
5047 result = (LRESULT)EDIT_WM_GetText(es, (INT)wParam, (LPWSTR)lParam);
5048 break;
5049
5050 case WM_GETTEXTLENGTH:
5051 result = get_text_length(es);
5052 break;
5053
5054 case WM_HSCROLL:
5055 result = EDIT_WM_HScroll(es, LOWORD(wParam), (short)HIWORD(wParam));
5056 break;
5057
5058 case WM_KEYDOWN:
5059 result = EDIT_WM_KeyDown(es, (INT)wParam);
5060 break;
5061
5062 case WM_KILLFOCUS:
5063 result = EDIT_WM_KillFocus(theme, es);
5064 break;
5065
5066 case WM_LBUTTONDBLCLK:
5067 result = EDIT_WM_LButtonDblClk(es);
5068 break;
5069
5070 case WM_LBUTTONDOWN:
5071 result = EDIT_WM_LButtonDown(es, wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
5072 break;
5073
5074 case WM_LBUTTONUP:
5075 result = EDIT_WM_LButtonUp(es);
5076 break;
5077
5078 case WM_MBUTTONDOWN:
5079 result = EDIT_WM_MButtonDown(es);
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:
5088 EDIT_WM_Paint(es, (HDC)wParam);
5089 break;
5090
5091 case WM_NCPAINT:
5092 EDIT_WM_NCPaint(hwnd, (HRGN)wParam);
5093 break;
5094
5095 case WM_PASTE:
5096 EDIT_WM_Paste(es);
5097 break;
5098
5099 case WM_SETFOCUS:
5100 EDIT_WM_SetFocus(theme, es);
5101 break;
5102
5103 case WM_SETFONT:
5104 EDIT_WM_SetFont(es, (HFONT)wParam, LOWORD(lParam) != 0);
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:
5117 EDIT_WM_Size(es, (UINT)wParam);
5118 break;
5119
5120 case WM_STYLECHANGED:
5121 result = EDIT_WM_StyleChanged(es, wParam, (const STYLESTRUCT *)lParam);
5122 break;
5123
5124 case WM_STYLECHANGING:
5125 result = 0; /* See EDIT_WM_StyleChanged */
5126 break;
5127
5128 case WM_SYSKEYDOWN:
5129 result = EDIT_WM_SysKeyDown(es, (INT)wParam, (DWORD)lParam);
5130 break;
5131
5132 case WM_TIMER:
5133 EDIT_WM_Timer(es);
5134 break;
5135
5136 case WM_VSCROLL:
5137 result = EDIT_WM_VScroll(es, LOWORD(wParam), (short)HIWORD(wParam));
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 {
5148 result = DefWindowProcW(hwnd, msg, wParam, lParam);
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);
5180 LPINPUTCONTEXTDX pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
5181 if (pIC)
5182 {
5183 pIC->dwUIFlags &= ~0x40000;
5184 ImmUnlockIMC(hIMC);
5185 }
5186 if (FALSE) /* FIXME: Condition */
5187 ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
5188 ImmReleaseContext(hwnd, hIMC);
5189 }
5190
5191 result = DefWindowProcW(hwnd, msg, wParam, lParam);
5192#endif
5193 break;
5194
5195 case WM_IME_STARTCOMPOSITION:
5196#ifdef __REACTOS__
5197 if (FALSE) /* FIXME: Condition */
5198 return TRUE;
5199 result = DefWindowProcW(hwnd, msg, wParam, lParam);
5200#else
5201 es->composition_start = es->selection_end;
5202 es->composition_len = 0;
5203#endif
5204 break;
5205
5206 case WM_IME_COMPOSITION:
5207 EDIT_ImeComposition(hwnd, lParam, es);
5208#ifdef __REACTOS__
5209 result = DefWindowProcW(hwnd, msg, wParam, lParam);
5210#endif
5211 break;
5212
5213 case WM_IME_ENDCOMPOSITION:
5214#ifdef __REACTOS__
5215 result = DefWindowProcW(hwnd, msg, wParam, lParam);
5216#else
5217 if (es->composition_len > 0)
5218 {
5219 EDIT_EM_ReplaceSel(es, TRUE, NULL, 0, TRUE, TRUE);
5220 es->selection_end = es->selection_start;
5221 es->composition_len= 0;
5222 }
5223#endif
5224 break;
5225
5226 case WM_IME_COMPOSITIONFULL:
5227 break;
5228
5229 case WM_IME_SELECT:
5230#ifdef __REACTOS__
5231 result = DefWindowProcW(hwnd, msg, wParam, lParam);
5232#endif
5233 break;
5234
5235 case WM_IME_CONTROL:
5236#ifdef __REACTOS__
5237 result = DefWindowProcW(hwnd, msg, wParam, lParam);
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);
5264 OpenThemeData(hwnd, WC_EDITW);
5265 break;
5266
5267 default:
5268 result = DefWindowProcW(hwnd, msg, wParam, lParam);
5269 break;
5270 }
5271
5272 if (IsWindow(hwnd) && es && msg != EM_GETHANDLE)
5273 EDIT_UnlockBuffer(es, FALSE);
5274
5275 TRACE("hwnd=%p msg=%x -- 0x%08lx\n", hwnd, msg, result);
5276
5277 return result;
wParam
WPARAM wParam
Definition: combotst.c:138
lParam
LPARAM lParam
Definition: combotst.c:139
EDIT_WM_Paint
static void EDIT_WM_Paint(EDITSTATE *es, HDC hdc)
Definition: edit.c:3620
EDIT_WM_LButtonDblClk
static LRESULT EDIT_WM_LButtonDblClk(EDITSTATE *es)
Definition: edit.c:3505
EDIT_WM_Char
static LRESULT EDIT_WM_Char(EDITSTATE *es, WCHAR c)
Definition: edit.c:3080
EDIT_WM_SetFont
static void EDIT_WM_SetFont(EDITSTATE *es, HFONT font, BOOL redraw)
Definition: edit.c:3829
EDIT_WM_MButtonDown
static LRESULT EDIT_WM_MButtonDown(EDITSTATE *es)
Definition: edit.c:3576
EDIT_SetRectNP
static void EDIT_SetRectNP(EDITSTATE *es, const RECT *rc)
Definition: edit.c:2319
EDIT_EM_FmtLines
static BOOL EDIT_EM_FmtLines(EDITSTATE *es, BOOL add_eol)
Definition: edit.c:2391
EDIT_WM_Copy
static void EDIT_WM_Copy(EDITSTATE *es)
Definition: edit.c:3024
EDIT_EM_GetCueBanner
static BOOL EDIT_EM_GetCueBanner(EDITSTATE *es, WCHAR *buf, DWORD size)
Definition: edit.c:4342
EDIT_EM_CharFromPos
static LRESULT EDIT_EM_CharFromPos(EDITSTATE *es, INT x, INT y)
Definition: edit.c:2363
EDIT_WM_Cut
static void EDIT_WM_Cut(EDITSTATE *es)
Definition: edit.c:3068
EDIT_EM_SetPasswordChar
static void EDIT_EM_SetPasswordChar(EDITSTATE *es, WCHAR c)
Definition: edit.c:2866
EDIT_WM_NCPaint
static void EDIT_WM_NCPaint(HWND hwnd, HRGN region)
Definition: edit.c:3709
EDIT_WM_GetText
static INT EDIT_WM_GetText(const EDITSTATE *es, INT count, LPWSTR dst)
Definition: edit.c:3267
EDIT_WM_ContextMenu
static void EDIT_WM_ContextMenu(EDITSTATE *es, INT x, INT y)
Definition: edit.c:3211
EDIT_WM_MouseMove
static LRESULT EDIT_WM_MouseMove(EDITSTATE *es, INT x, INT y)
Definition: edit.c:3588
EDIT_WM_NCDestroy
static LRESULT EDIT_WM_NCDestroy(EDITSTATE *es)
Definition: edit.c:4687
EDIT_WM_LButtonDown
static LRESULT EDIT_WM_LButtonDown(EDITSTATE *es, DWORD keys, INT x, INT y)
Definition: edit.c:3534
EDIT_EM_GetHandle
static HLOCAL EDIT_EM_GetHandle(EDITSTATE *es)
Definition: edit.c:2413
EDIT_EM_GetLine
static INT EDIT_EM_GetLine(EDITSTATE *es, INT line, LPWSTR dst)
Definition: edit.c:2433
EDIT_EM_Undo
static BOOL EDIT_EM_Undo(EDITSTATE *es)
Definition: edit.c:2936
EDIT_WM_Paste
static void EDIT_WM_Paste(EDITSTATE *es)
Definition: edit.c:2988
EDIT_WM_KillFocus
static LRESULT EDIT_WM_KillFocus(HTHEME theme, EDITSTATE *es)
Definition: edit.c:3477
EDIT_WM_SysKeyDown
static LRESULT EDIT_WM_SysKeyDown(EDITSTATE *es, INT key, DWORD key_data)
Definition: edit.c:4017
EDIT_EM_GetThumb
static LRESULT EDIT_EM_GetThumb(EDITSTATE *es)
Definition: edit.c:4306
EDIT_WM_NCCreate
static LRESULT EDIT_WM_NCCreate(HWND hwnd, LPCREATESTRUCTW lpcs)
Definition: edit.c:4519
EDIT_WM_LButtonUp
static LRESULT EDIT_WM_LButtonUp(EDITSTATE *es)
Definition: edit.c:3560
EDIT_WM_Clear
static void EDIT_WM_Clear(EDITSTATE *es)
Definition: edit.c:3053
EDIT_EM_CanUndo
static BOOL EDIT_EM_CanUndo(const EDITSTATE *es)
Definition: edit.c:181
EDIT_EM_SetMargins
static void EDIT_EM_SetMargins(EDITSTATE *es, INT action, WORD left, WORD right, BOOL repaint)
Definition: edit.c:2794
EDIT_WM_SetFocus
static void EDIT_WM_SetFocus(HTHEME theme, EDITSTATE *es)
Definition: edit.c:3771
EDIT_EM_SetHandle
static void EDIT_EM_SetHandle(EDITSTATE *es, HLOCAL hloc)
Definition: edit.c:2705
EDIT_WM_Create
static LRESULT EDIT_WM_Create(EDITSTATE *es, const WCHAR *name)
Definition: edit.c:4632
EDIT_WM_KeyDown
static LRESULT EDIT_WM_KeyDown(EDITSTATE *es, INT key)
Definition: edit.c:3343
EDIT_EM_SetLimitText
static void EDIT_EM_SetLimitText(EDITSTATE *es, UINT limit)
Definition: edit.c:2744
EDIT_WM_Timer
static void EDIT_WM_Timer(EDITSTATE *es)
Definition: edit.c:4036
EDIT_EM_SetCueBanner
static BOOL EDIT_EM_SetCueBanner(EDITSTATE *es, BOOL draw_focused, const WCHAR *cue_text)
Definition: edit.c:4325
EDIT_EM_Scroll
static LRESULT EDIT_EM_Scroll(EDITSTATE *es, INT action)
Definition: edit.c:1672
EDIT_EM_GetSel
static LRESULT EDIT_EM_GetSel(const EDITSTATE *es, PUINT start, PUINT end)
Definition: edit.c:2471
EDIT_EM_SetWordBreakProc
static void EDIT_EM_SetWordBreakProc(EDITSTATE *es, EDITWORDBREAKPROCW wbp)
Definition: edit.c:2917
EDIT_WM_StyleChanged
static LRESULT EDIT_WM_StyleChanged(EDITSTATE *es, WPARAM which, const STYLESTRUCT *style)
Definition: edit.c:3977
EDIT_WM_SetText
static void EDIT_WM_SetText(EDITSTATE *es, LPCWSTR text)
Definition: edit.c:3902
EDIT_EM_SetTabStops
static BOOL EDIT_EM_SetTabStops(EDITSTATE *es, INT count, const INT *tabs)
Definition: edit.c:2895
EDIT_ImeComposition
static void EDIT_ImeComposition(HWND hwnd, LPARAM CompFlag, EDITSTATE *es)
Definition: edit.c:4473
EDIT_WM_Size
static void EDIT_WM_Size(EDITSTATE *es, UINT action)
Definition: edit.c:3944
ImmNotifyIME
BOOL WINAPI ImmNotifyIME(HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD_PTR dwValue)
Definition: ime.c:907
ImmUnlockIMC
BOOL WINAPI ImmUnlockIMC(HIMC hIMC)
Definition: imm.c:1067
ImmLockIMC
LPINPUTCONTEXT WINAPI ImmLockIMC(HIMC hIMC)
Definition: imm.c:1058
OpenThemeData
HTHEME WINAPI OpenThemeData(HWND hwnd, LPCWSTR classlist)
Definition: system.c:835
GetWindowTheme
HTHEME WINAPI GetWindowTheme(HWND hwnd)
Definition: system.c:851
CloseThemeData
HRESULT WINAPI CloseThemeData(HTHEME hTheme)
Definition: system.c:950
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
result
GLuint64EXT * result
Definition: glext.h:11304
LPINPUTCONTEXTDX
struct INPUTCONTEXTDX * LPINPUTCONTEXTDX
CPS_CANCEL
#define CPS_CANCEL
Definition: imm.h:181
NI_COMPOSITIONSTR
#define NI_COMPOSITIONSTR
Definition: immdev.h:403
textW
static const WCHAR textW[]
Definition: itemdlg.c:1559
vk
WORD vk
Definition: input.c:77
HTHEME
static HTHEME(WINAPI *pOpenThemeDataEx)(HWND
LRESULT
#define LRESULT
Definition: ole.h:14
EM_GETCUEBANNER
#define EM_GETCUEBANNER
Definition: commctrl.h:4698
EM_SETCUEBANNER
#define EM_SETCUEBANNER
Definition: commctrl.h:4696
EM_SCROLLCARET
#define EM_SCROLLCARET
Definition: richedit.h:81
WM_UNICHAR
#define WM_UNICHAR
Definition: richedit.h:67
EM_POSFROMCHAR
#define EM_POSFROMCHAR
Definition: richedit.h:77
WM_CONTEXTMENU
#define WM_CONTEXTMENU
Definition: richedit.h:64
EM_CHARFROMPOS
#define EM_CHARFROMPOS
Definition: richedit.h:78
WM_PRINTCLIENT
#define WM_PRINTCLIENT
Definition: richedit.h:70
EM_GETLIMITTEXT
#define EM_GETLIMITTEXT
Definition: richedit.h:74
rect
& rect
Definition: startmenu.cpp:1413
WHEEL_DELTA
#define WHEEL_DELTA
Definition: treelist.c:99
WM_MOUSEWHEEL
#define WM_MOUSEWHEEL
Definition: treelist.c:96
MSG
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
LPINT
int * LPINT
Definition: windef.h:178
WM_PAINT
#define WM_PAINT
Definition: winuser.h:1623
EM_SETREADONLY
#define EM_SETREADONLY
Definition: winuser.h:2018
WM_ERASEBKGND
#define WM_ERASEBKGND
Definition: winuser.h:1628
MK_SHIFT
#define MK_SHIFT
Definition: winuser.h:2372
WM_GETTEXTLENGTH
#define WM_GETTEXTLENGTH
Definition: winuser.h:1622
EM_GETRECT
#define EM_GETRECT
Definition: winuser.h:1999
WM_IME_REQUEST
#define WM_IME_REQUEST
Definition: winuser.h:1839
RedrawWindow
BOOL WINAPI RedrawWindow(_In_opt_ HWND, _In_opt_ LPCRECT, _In_opt_ HRGN, _In_ UINT)
EM_LINEFROMCHAR
#define EM_LINEFROMCHAR
Definition: winuser.h:2004
WM_ENABLE
#define WM_ENABLE
Definition: winuser.h:1618
WM_HSCROLL
#define WM_HSCROLL
Definition: winuser.h:1746
EM_GETWORDBREAKPROC
#define EM_GETWORDBREAKPROC
Definition: winuser.h:2002
EM_FMTLINES
#define EM_FMTLINES
Definition: winuser.h:1989
EM_GETPASSWORDCHAR
#define EM_GETPASSWORDCHAR
Definition: winuser.h:1998
WM_VSCROLL
#define WM_VSCROLL
Definition: winuser.h:1747
WM_CREATE
#define WM_CREATE
Definition: winuser.h:1611
DLGC_WANTCHARS
#define DLGC_WANTCHARS
Definition: winuser.h:2621
EM_GETSEL
#define EM_GETSEL
Definition: winuser.h:2000
EM_SETPASSWORDCHAR
#define EM_SETPASSWORDCHAR
Definition: winuser.h:2017
EM_GETMODIFY
#define EM_GETMODIFY
Definition: winuser.h:1997
WM_SIZE
#define WM_SIZE
Definition: winuser.h:1614
EM_EMPTYUNDOBUFFER
#define EM_EMPTYUNDOBUFFER
Definition: winuser.h:1988
DLGC_WANTALLKEYS
#define DLGC_WANTALLKEYS
Definition: winuser.h:2615
WM_LBUTTONDBLCLK
#define WM_LBUTTONDBLCLK
Definition: winuser.h:1781
EM_REPLACESEL
#define EM_REPLACESEL
Definition: winuser.h:2009
EM_SETRECT
#define EM_SETRECT
Definition: winuser.h:2019
WM_SETFOCUS
#define WM_SETFOCUS
Definition: winuser.h:1616
WM_MOUSEMOVE
#define WM_MOUSEMOVE
Definition: winuser.h:1778
WM_GETTEXT
#define WM_GETTEXT
Definition: winuser.h:1621
RDW_UPDATENOW
#define RDW_UPDATENOW
Definition: winuser.h:1223
WM_LBUTTONDOWN
#define WM_LBUTTONDOWN
Definition: winuser.h:1779
EM_LINEINDEX
#define EM_LINEINDEX
Definition: winuser.h:2005
MapWindowPoints
int WINAPI MapWindowPoints(_In_opt_ HWND hWndFrom, _In_opt_ HWND hWndTo, _Inout_updates_(cPoints) LPPOINT lpPoints, _In_ UINT cPoints)
WM_GETFONT
#define WM_GETFONT
Definition: winuser.h:1654
EM_LINESCROLL
#define EM_LINESCROLL
Definition: winuser.h:2007
EM_GETFIRSTVISIBLELINE
#define EM_GETFIRSTVISIBLELINE
Definition: winuser.h:1991
EM_GETHANDLE
#define EM_GETHANDLE
Definition: winuser.h:1992
WM_NCCREATE
#define WM_NCCREATE
Definition: winuser.h:1686
WM_IME_SETCONTEXT
#define WM_IME_SETCONTEXT
Definition: winuser.h:1832
WM_SETTEXT
#define WM_SETTEXT
Definition: winuser.h:1620
EM_CANUNDO
#define EM_CANUNDO
Definition: winuser.h:1986
EM_LINELENGTH
#define EM_LINELENGTH
Definition: winuser.h:2006
WM_IME_CHAR
#define WM_IME_CHAR
Definition: winuser.h:1837
EM_SETHANDLE
#define EM_SETHANDLE
Definition: winuser.h:2012
VK_RETURN
#define VK_RETURN
Definition: winuser.h:2204
EM_GETLINE
#define EM_GETLINE
Definition: winuser.h:1994
EM_SETRECTNP
#define EM_SETRECTNP
Definition: winuser.h:2020
MK_CONTROL
#define MK_CONTROL
Definition: winuser.h:2373
EM_SETLIMITTEXT
#define EM_SETLIMITTEXT
Definition: winuser.h:2014
WM_SETFONT
#define WM_SETFONT
Definition: winuser.h:1653
WM_TIMER
#define WM_TIMER
Definition: winuser.h:1745
DLGC_WANTARROWS
#define DLGC_WANTARROWS
Definition: winuser.h:2613
EM_SCROLL
#define EM_SCROLL
Definition: winuser.h:2010
RDW_FRAME
#define RDW_FRAME
Definition: winuser.h:1215
EM_SETWORDBREAKPROC
#define EM_SETWORDBREAKPROC
Definition: winuser.h:2023
WM_LBUTTONUP
#define WM_LBUTTONUP
Definition: winuser.h:1780
SystemParametersInfoW
BOOL WINAPI SystemParametersInfoW(_In_ UINT uiAction, _In_ UINT uiParam, _Inout_opt_ PVOID pvParam, _In_ UINT fWinIni)
WM_IME_COMPOSITIONFULL
#define WM_IME_COMPOSITIONFULL
Definition: winuser.h:1835
WM_CHAR
#define WM_CHAR
Definition: winuser.h:1720
WM_NCDESTROY
#define WM_NCDESTROY
Definition: winuser.h:1687
EM_GETMARGINS
#define EM_GETMARGINS
Definition: winuser.h:1996
WM_IME_CONTROL
#define WM_IME_CONTROL
Definition: winuser.h:1834
EM_SETTABSTOPS
#define EM_SETTABSTOPS
Definition: winuser.h:2022
DLGC_WANTMESSAGE
#define DLGC_WANTMESSAGE
Definition: winuser.h:2616
WM_IME_SELECT
#define WM_IME_SELECT
Definition: winuser.h:1836
EM_GETLINECOUNT
#define EM_GETLINECOUNT
Definition: winuser.h:1995
EM_SETMARGINS
#define EM_SETMARGINS
Definition: winuser.h:2015
VK_ESCAPE
#define VK_ESCAPE
Definition: winuser.h:2217
DLGC_HASSETSEL
#define DLGC_HASSETSEL
Definition: winuser.h:2617
WM_KILLFOCUS
#define WM_KILLFOCUS
Definition: winuser.h:1617
RDW_INVALIDATE
#define RDW_INVALIDATE
Definition: winuser.h:1217
WM_GETDLGCODE
#define WM_GETDLGCODE
Definition: winuser.h:1692
WM_MBUTTONDOWN
#define WM_MBUTTONDOWN
Definition: winuser.h:1785
EM_SETMODIFY
#define EM_SETMODIFY
Definition: winuser.h:2016
WM_NCPAINT
#define WM_NCPAINT
Definition: winuser.h:1690
WM_SETREDRAW
#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))
3099 if (EDIT_IsInsideDialog(es))
3100 break;
3101 case '\n':
3102 if (es->style & ES_MULTILINE) {
3103 if (es->style & ES_READONLY) {
3104 EDIT_MoveHome(es, FALSE, FALSE);
3105 EDIT_MoveDown_ML(es, FALSE);
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'};
3116 if (EDIT_IsInsideDialog(es))
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)
3124 EDIT_WM_Clear(es);
3125 else {
3126 /* delete character left of caret */
3127 EDIT_EM_SetSel(es, (UINT)-1, 0, FALSE);
3128 EDIT_MoveBackward(es, TRUE);
3129 EDIT_WM_Clear(es);
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))
3156 EDIT_EM_ReplaceSel(es, TRUE, &c, 1, TRUE, TRUE);
3157 break;
3158 }
3159 return 1;
EDIT_IsInsideDialog
static BOOL EDIT_IsInsideDialog(EDITSTATE *es)
Definition: edit.c:2977
EDIT_MoveBackward
static void EDIT_MoveBackward(EDITSTATE *es, BOOL extend)
Definition: edit.c:1849
EDIT_MoveHome
static void EDIT_MoveHome(EDITSTATE *es, BOOL extend, BOOL ctrl)
Definition: edit.c:1944
EDIT_MoveDown_ML
static void EDIT_MoveDown_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:1876
ES_WANTRETURN
#define ES_WANTRETURN
Definition: pedump.c:676
control
Definition: dialog.c:52
VK_CONTROL
#define VK_CONTROL
Definition: winuser.h:2206
VK_BACK
#define VK_BACK
Definition: winuser.h:2201
ES_NUMBER
#define ES_NUMBER
Definition: winuser.h:301
GetKeyState
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
3060 EDIT_EM_ReplaceSel(es, TRUE, NULL, 0, TRUE, TRUE);

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
3221 ORDER_UINT(start, end);
3222
3223 /* undo */
3224 EnableMenuItem(popup, 0, MF_BYPOSITION | (EDIT_EM_CanUndo(es) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
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 */
3230 EnableMenuItem(popup, 4, MF_BYPOSITION | (IsClipboardFormatAvailable(CF_UNICODETEXT) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
3231 /* delete */
3232 EnableMenuItem(popup, 5, MF_BYPOSITION | ((end - start) && !(es->style & ES_READONLY) ? MF_ENABLED : MF_GRAYED));
3233 /* select all */
3234 EnableMenuItem(popup, 7, MF_BYPOSITION | (start || (end != get_text_length(es)) ? MF_ENABLED : MF_GRAYED));
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
3253 cmd = TrackPopupMenu(popup, TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD | TPM_NONOTIFY,
3254 pt.x, pt.y, 0, es->hwndSelf, NULL);
3255
3256 if (cmd)
3257 EDIT_ContextMenuCommand(es, cmd);
3258
3259 DestroyMenu(menu);
CF_UNICODETEXT
#define CF_UNICODETEXT
Definition: constants.h:408
EDIT_ContextMenuCommand
static void EDIT_ContextMenuCommand(EDITSTATE *es, UINT id)
Definition: edit.c:3167
GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
HMENU
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
cmd
Definition: ftp_var.h:139
TPM_RIGHTBUTTON
#define TPM_RIGHTBUTTON
Definition: winuser.h:2383
TPM_NONOTIFY
#define TPM_NONOTIFY
Definition: winuser.h:2389
ClientToScreen
BOOL WINAPI ClientToScreen(_In_ HWND, _Inout_ LPPOINT)
GetSubMenu
HMENU WINAPI GetSubMenu(_In_ HMENU, _In_ int)
SetFocus
HWND WINAPI SetFocus(_In_opt_ HWND)
MF_ENABLED
#define MF_ENABLED
Definition: winuser.h:128
TPM_LEFTALIGN
#define TPM_LEFTALIGN
Definition: winuser.h:2380
MF_BYPOSITION
#define MF_BYPOSITION
Definition: winuser.h:203
DestroyMenu
BOOL WINAPI DestroyMenu(_In_ HMENU)
TrackPopupMenu
BOOL WINAPI TrackPopupMenu(_In_ HMENU, _In_ UINT, _In_ int, _In_ int, _Reserved_ int, _In_ HWND, _Reserved_ LPCRECT)
TPM_RETURNCMD
#define TPM_RETURNCMD
Definition: winuser.h:2390
EnableMenuItem
BOOL WINAPI EnableMenuItem(_In_ HMENU, _In_ UINT, _In_ UINT)
IsClipboardFormatAvailable
BOOL WINAPI IsClipboardFormatAvailable(_In_ UINT)
MF_GRAYED
#define MF_GRAYED
Definition: winuser.h:129
LoadMenuA
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);
3043 EmptyClipboard();
3044 SetClipboardData(CF_UNICODETEXT, hdst);
3045 CloseClipboard();
GlobalLock
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
GlobalUnlock
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
GlobalAlloc
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:368
GMEM_MOVEABLE
#define GMEM_MOVEABLE
Definition: winbase.h:319
GMEM_DDESHARE
#define GMEM_DDESHARE
Definition: winbase.h:323
SetClipboardData
HANDLE WINAPI SetClipboardData(_In_ UINT, _In_opt_ HANDLE)
CloseClipboard
BOOL WINAPI CloseClipboard(void)
Definition: ntwrapper.h:178
OpenClipboard
BOOL WINAPI OpenClipboard(_In_opt_ HWND)
EmptyClipboard
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 */
4645 EDIT_WM_SetFont(es, 0, FALSE);
4646 EDIT_EM_EmptyUndoBuffer(es);
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 {
4655 EDIT_EM_ReplaceSel(es, FALSE, name, lstrlenW(name), FALSE, FALSE);
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 */
4668 EDIT_EM_ScrollCaret(es);
4669 }
4670
4671 /* force scroll info update */
4672 EDIT_UpdateScrollInfo(es);
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;
name
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{
3071 EDIT_WM_Copy(es);
3072 EDIT_WM_Clear(es);

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 */
4132 EDIT_UpdateScrollInfo(es);
4133 notify_parent(es, EN_HSCROLL);
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)
4176 EDIT_EM_LineScroll_internal(es, dx, 0);
4177 }
4178 return 0;
SB_THUMBTRACK
#define SB_THUMBTRACK
Definition: winuser.h:573
SB_PAGERIGHT
#define SB_PAGERIGHT
Definition: winuser.h:571
SB_LEFT
#define SB_LEFT
Definition: winuser.h:575
SB_LINERIGHT
#define SB_LINERIGHT
Definition: winuser.h:567
SB_LINELEFT
#define SB_LINELEFT
Definition: winuser.h:566
SB_ENDSCROLL
#define SB_ENDSCROLL
Definition: winuser.h:574
SB_RIGHT
#define SB_RIGHT
Definition: winuser.h:576
GetScrollPos
int WINAPI GetScrollPos(_In_ HWND, _In_ int)
SB_PAGELEFT
#define SB_PAGELEFT
Definition: winuser.h:570
SB_THUMBPOSITION
#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:
3358 if (EDIT_CheckCombo(es, WM_KEYDOWN, key) || key == VK_F4)
3359 break;
3360
3361 /* fall through */
3362 case VK_LEFT:
3363 if ((es->style & ES_MULTILINE) && (key == VK_UP))
3364 EDIT_MoveUp_ML(es, shift);
3365 else
3366 if (control)
3367 EDIT_MoveWordBackward(es, shift);
3368 else
3369 EDIT_MoveBackward(es, shift);
3370 break;
3371 case VK_DOWN:
3372 if (EDIT_CheckCombo(es, WM_KEYDOWN, key))
3373 break;
3374 /* fall through */
3375 case VK_RIGHT:
3376 if ((es->style & ES_MULTILINE) && (key == VK_DOWN))
3377 EDIT_MoveDown_ML(es, shift);
3378 else if (control)
3379 EDIT_MoveWordForward(es, shift);
3380 else
3381 EDIT_MoveForward(es, shift);
3382 break;
3383 case VK_HOME:
3384 EDIT_MoveHome(es, shift, control);
3385 break;
3386 case VK_END:
3387 EDIT_MoveEnd(es, shift, control);
3388 break;
3389 case VK_PRIOR:
3390 if (es->style & ES_MULTILINE)
3391 EDIT_MovePageUp_ML(es, shift);
3392 else
3393 EDIT_CheckCombo(es, WM_KEYDOWN, key);
3394 break;
3395 case VK_NEXT:
3396 if (es->style & ES_MULTILINE)
3397 EDIT_MovePageDown_ML(es, shift);
3398 else
3399 EDIT_CheckCombo(es, WM_KEYDOWN, key);
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
3407 EDIT_WM_Clear(es);
3408 } else {
3409 EDIT_EM_SetSel(es, ~0u, 0, FALSE);
3410 if (shift)
3411 /* delete character left of caret */
3412 EDIT_MoveBackward(es, TRUE);
3413 else if (control)
3414 /* delete to end of line */
3415 EDIT_MoveEnd(es, TRUE, FALSE);
3416 else
3417 /* delete character right of caret */
3418 EDIT_MoveForward(es, TRUE);
3419 EDIT_WM_Clear(es);
3420 }
3421 }
3422 break;
3423 case VK_INSERT:
3424 if (shift) {
3425 if (!(es->style & ES_READONLY))
3426 EDIT_WM_Paste(es);
3427 } else if (control)
3428 EDIT_WM_Copy(es);
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 {
3461 if (EDIT_EM_SetSel(es, 0, get_text_length(es), FALSE))
3462 {
3463 if (!notify_parent(es, EN_UPDATE)) break;
3464 notify_parent(es, EN_CHANGE);
3465 }
3466 }
3467 break;
3468 }
3469 return TRUE;
EDIT_MoveEnd
static void EDIT_MoveEnd(EDITSTATE *es, BOOL extend, BOOL ctrl)
Definition: edit.c:1898
EDIT_CheckCombo
static BOOL EDIT_CheckCombo(EDITSTATE *es, UINT msg, INT key)
Definition: edit.c:3281
EDIT_MoveUp_ML
static void EDIT_MoveUp_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:2024
EDIT_MovePageUp_ML
static void EDIT_MovePageUp_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:1996
EDIT_MovePageDown_ML
static void EDIT_MovePageDown_ML(EDITSTATE *es, BOOL extend)
Definition: edit.c:1968
EDIT_MoveWordForward
static void EDIT_MoveWordForward(EDITSTATE *es, BOOL extend)
Definition: edit.c:2077
EDIT_MoveWordBackward
static void EDIT_MoveWordBackward(EDITSTATE *es, BOOL extend)
Definition: edit.c:2046
EDIT_MoveForward
static void EDIT_MoveForward(EDITSTATE *es, BOOL extend)
Definition: edit.c:1919
dw
REFIID LPVOID DWORD_PTR dw
Definition: atlbase.h:40
shift
#define shift
Definition: input.c:1755
WM_CLOSE
#define WM_CLOSE
Definition: winuser.h:1624
VK_TAB
#define VK_TAB
Definition: winuser.h:2202
PostMessageW
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
DC_HASDEFID
#define DC_HASDEFID
Definition: winuser.h:2612
GetDlgItem
HWND WINAPI GetDlgItem(_In_opt_ HWND, _In_ int)
WM_NEXTDLGCTL
#define WM_NEXTDLGCTL
Definition: winuser.h:1646
VK_NEXT
#define VK_NEXT
Definition: winuser.h:2224
VK_END
#define VK_END
Definition: winuser.h:2225
VK_HOME
#define VK_HOME
Definition: winuser.h:2226
VK_LEFT
#define VK_LEFT
Definition: winuser.h:2227
VK_RIGHT
#define VK_RIGHT
Definition: winuser.h:2229
VK_SHIFT
#define VK_SHIFT
Definition: winuser.h:2205
VK_PRIOR
#define VK_PRIOR
Definition: winuser.h:2223
VK_DELETE
#define VK_DELETE
Definition: winuser.h:2236
DM_GETDEFID
#define DM_GETDEFID
Definition: winuser.h:2101
VK_INSERT
#define VK_INSERT
Definition: winuser.h:2235
VK_MENU
#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{
3480 UINT flags = RDW_INVALIDATE | RDW_UPDATENOW;
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;
flags
GLbitfield flags
Definition: glext.h:7161
EN_KILLFOCUS
#define EN_KILLFOCUS
Definition: winuser.h:2028
DestroyCaret
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
3517 l = EDIT_EM_LineFromChar(es, e);
3518 li = EDIT_EM_LineIndex(es, l);
3519 ll = EDIT_EM_LineLength(es, e);
3520 s = li + EDIT_CallWordBreakProc(es, li, e - li, ll, WB_LEFT);
3521 e = li + EDIT_CallWordBreakProc(es, li, e - li, ll, WB_RIGHT);
3522 EDIT_EM_SetSel(es, s, e, FALSE);
3523 EDIT_EM_ScrollCaret(es);
3524 es->region_posx = es->region_posy = 0;
3525 SetTimer(es->hwndSelf, 0, 100, NULL);
3526 return 0;
SetCapture
HWND WINAPI SetCapture(_In_ HWND hWnd)
SetTimer
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);
3545 EDIT_EM_ScrollCaret(es);
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;
EDIT_ConfinePoint
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;
ReleaseCapture
BOOL WINAPI ReleaseCapture(void)
Definition: message.c:2890
GetCapture
HWND WINAPI GetCapture(void)
Definition: message.c:2881
KillTimer
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;
4529 SetWindowLongPtrW( hwnd, 0, (LONG_PTR)es );
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)
4612 SetWindowLongW(hwnd, GWL_STYLE, es->style & ~WS_BORDER);
4613
4614 return TRUE;
4615
4616cleanup:
4617 SetWindowLongPtrW(es->hwndSelf, 0, 0);
4618 EDIT_InvalidateUniscribeData(es);
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;
ID_CB_LISTBOX
#define ID_CB_LISTBOX
Definition: edit.c:74
BUFLIMIT_INITIAL
#define BUFLIMIT_INITIAL
Definition: edit.c:57
cleanup
static void cleanup(void)
Definition: main.c:1335
LocalAlloc
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
LocalFree
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
ES_COMBO
#define ES_COMBO
Definition: edit.c:29
WS_DISABLED
#define WS_DISABLED
Definition: pedump.c:621
SetWindowLongPtrW
#define SetWindowLongPtrW
Definition: winuser.h:5358
WS_EX_RIGHT
#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
4700 EDIT_InvalidateUniscribeData(es);
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{
3712 DWORD exStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
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))
3727 state = ETS_DISABLED;
3728 else if (dwStyle & ES_READONLY)
3729 state = ETS_READONLY;
3730 else if (GetFocus() == hwnd)
3731 state = ETS_FOCUSED;
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 */
3745 ExcludeClipRect(dc,
3746 r.left + cxEdge,
3747 r.top + cyEdge,
3748 r.right - cxEdge,
3749 r.bottom -cyEdge);
3750#else
3751 dc = GetDCEx(hwnd, region, DCX_WINDOW|DCX_INTERSECTRGN);
3752 OffsetRect(&r, -r.left, -r.top);
3753#endif
3754
3755 if (IsThemeBackgroundPartiallyTransparent(theme, part, state))
3756 DrawThemeParentBackground(hwnd, dc, &r);
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);
state
static int state
Definition: maze.c:121
DrawThemeBackground
HRESULT WINAPI DrawThemeBackground(HTHEME hTheme, HDC hdc, int iPartId, int iStateId, const RECT *pRect, const RECT *pClipRect)
Definition: draw.c:128
IsThemeBackgroundPartiallyTransparent
BOOL WINAPI IsThemeBackgroundPartiallyTransparent(HTHEME hTheme, int iPartId, int iStateId)
Definition: draw.c:1927
DrawThemeParentBackground
HRESULT WINAPI DrawThemeParentBackground(HWND hwnd, HDC hdc, RECT *prc)
Definition: draw.c:72
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
EP_EDITTEXT
@ EP_EDITTEXT
Definition: vsstyle.h:419
ETS_DISABLED
@ ETS_DISABLED
Definition: vsstyle.h:436
ETS_READONLY
@ ETS_READONLY
Definition: vsstyle.h:438
ETS_NORMAL
@ ETS_NORMAL
Definition: vsstyle.h:433
ETS_FOCUSED
@ ETS_FOCUSED
Definition: vsstyle.h:437
ExcludeClipRect
int WINAPI ExcludeClipRect(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
RGN_AND
#define RGN_AND
Definition: wingdi.h:356
GetFocus
HWND WINAPI GetFocus(void)
Definition: window.c:1865
GetWindowDC
HDC WINAPI GetWindowDC(_In_opt_ HWND)
SM_CYEDGE
#define SM_CYEDGE
Definition: winuser.h:1012
DCX_WINDOW
#define DCX_WINDOW
Definition: winuser.h:2116
SM_CXEDGE
#define SM_CXEDGE
Definition: winuser.h:1011
GetWindowRect
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
GetDCEx
HDC WINAPI GetDCEx(_In_opt_ HWND, _In_opt_ HRGN, _In_ DWORD)
DCX_INTERSECTRGN
#define DCX_INTERSECTRGN
Definition: winuser.h:2125
IsWindowEnabled
BOOL WINAPI IsWindowEnabled(_In_ HWND)
OffsetRect
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. */
3641 EDIT_InvalidateUniscribeData(es);
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) {
3651 bw = GetSystemMetrics(SM_CXBORDER);
3652 bh = GetSystemMetrics(SM_CYBORDER);
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 */
3660 old_brush = SelectObject(dc, GetSysColorBrush(COLOR_WINDOWFRAME));
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)
3687 SetTextColor(dc, GetSysColor(COLOR_GRAYTEXT));
3688 GetClipBox(dc, &rcRgn);
3689 if (es->style & ES_MULTILINE) {
3690 INT vlc = get_vertical_line_count(es);
3691 for (i = es->y_offset ; i <= min(es->y_offset + vlc, es->y_offset + es->line_count - 1) ; i++) {
3692 EDIT_UpdateUniscribeData(es, dc, 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 {
3698 EDIT_UpdateUniscribeData(es, dc, 0);
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);
EDIT_PaintLine
static void EDIT_PaintLine(EDITSTATE *es, HDC dc, INT line, BOOL rev)
Definition: edit.c:2181
EDIT_NotifyCtlColor
static HBRUSH EDIT_NotifyCtlColor(EDITSTATE *es, HDC hdc)
Definition: edit.c:198
GetClipBox
int WINAPI GetClipBox(_In_ HDC, _Out_ LPRECT)
IntersectClipRect
int WINAPI IntersectClipRect(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
PATCOPY
#define PATCOPY
Definition: wingdi.h:335
PatBlt
BOOL WINAPI PatBlt(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_ DWORD)
FillRect
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
COLOR_WINDOWFRAME
#define COLOR_WINDOWFRAME
Definition: winuser.h:922
GetSysColorBrush
HBRUSH WINAPI GetSysColorBrush(_In_ int)
EndPaint
BOOL WINAPI EndPaint(_In_ HWND, _In_ const PAINTSTRUCT *)
BeginPaint
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 }
3009 EDIT_EM_ReplaceSel(es, TRUE, src, len, TRUE, TRUE);
3010 GlobalUnlock(hsrc);
3011 }
3012 else if (es->style & ES_PASSWORD) {
3013 /* clear selected text in password edit box even with empty clipboard */
3014 EDIT_EM_ReplaceSel(es, TRUE, NULL, 0, TRUE, TRUE);
3015 }
3016 CloseClipboard();
wcschr
#define wcschr
Definition: compat.h:17
ptr
static PVOID ptr
Definition: dispmode.c:27
GetClipboardData
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{
3774 UINT flags = RDW_INVALIDATE | RDW_UPDATENOW;
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)
3792 flags |= RDW_FRAME | RDW_ERASE;
3793
3794 RedrawWindow(es->hwndSelf, NULL, NULL, flags);
ShowCaret
BOOL WINAPI ShowCaret(_In_opt_ HWND)
EN_SETFOCUS
#define EN_SETFOCUS
Definition: winuser.h:2030
RDW_ERASE
#define RDW_ERASE
Definition: winuser.h:1214
CreateCaret
BOOL WINAPI CreateCaret(_In_ HWND, _In_opt_ HBITMAP, _In_ int, _In_ int)
SystemParametersInfo
#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{
3832 TEXTMETRICW tm;
3833 HDC dc;
3834 HFONT old_font = 0;
3835 RECT clientRect;
3836 DWORD margins;
3837
3838 es->font = font;
3839 EDIT_InvalidateUniscribeData(es);
3840 dc = GetDC(es->hwndSelf);
3841 if (font)
3842 old_font = SelectObject(dc, font);
3843 GetTextMetricsW(dc, &tm);
3844 es->line_height = tm.tmHeight;
3845 es->char_width = tm.tmAveCharWidth;
3846 margins = get_font_margins(dc, &tm);
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)
3855 EDIT_EM_SetMargins(es, EC_LEFTMARGIN | EC_RIGHTMARGIN,
3856 LOWORD(margins), HIWORD(margins), FALSE);
3857
3858 if (es->style & ES_MULTILINE)
3859 EDIT_BuildLineDefs_ML(es, 0, get_text_length(es), 0, NULL);
3860 else
3861 EDIT_CalcLineWidth_SL(es);
3862
3863 if (redraw)
3864 EDIT_UpdateText(es, NULL, TRUE);
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__
3877 if (ImmIsIME(GetKeyboardLayout(0)))
3878 {
3879 LOGFONTW lf;
3880 HIMC hIMC = ImmGetContext(es->hwndSelf);
3881 if (font == NULL)
3882 font = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
3883 GetObjectW(font, sizeof(lf), &lf);
3884 ImmSetCompositionFontW(hIMC, &lf);
3885 ImmReleaseContext(es->hwndSelf, hIMC);
3886 }
3887#endif
margins
static RECT margins
Definition: print.c:55
get_font_margins
static DWORD get_font_margins(HDC hdc, const TEXTMETRICW *tm)
Definition: edit.c:3797
ImmSetCompositionFontW
BOOL WINAPI ImmSetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
Definition: ime.c:1744
font
Definition: mk_font.cpp:20
redraw
void redraw(int x, int y, int cx, int cy)
Definition: qtewin.cpp:1248
GetTextMetricsW
BOOL WINAPI GetTextMetricsW(_In_ HDC, _Out_ LPTEXTMETRICW)
Definition: text.c:221
GetStockObject
HGDIOBJ WINAPI GetStockObject(_In_ int)
DEFAULT_GUI_FONT
#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));
3914 EDIT_EM_ReplaceSel(es, FALSE, text, lstrlenW(text), FALSE, FALSE);
3915 }
3916 else
3917 {
3918 TRACE("<NULL>\n");
3919 EDIT_EM_ReplaceSel(es, FALSE, NULL, 0, FALSE, FALSE);
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 }
3934 EDIT_EM_ScrollCaret(es);
3935 EDIT_UpdateScrollInfo(es);
3936 EDIT_InvalidateUniscribeData(es);

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);
3951 EDIT_UpdateText(es, NULL, TRUE);
3952 }
SIZE_MAXIMIZED
#define SIZE_MAXIMIZED
Definition: winuser.h:2510
SIZE_RESTORED
#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;
which
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))
4022 EDIT_EM_Undo(es);
4023 return 0;
4024 } else if (key == VK_UP || key == VK_DOWN) {
4025 if (EDIT_CheckCombo(es, WM_SYSKEYDOWN, key))
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) {
4040 EDIT_MoveBackward(es, TRUE);
4041 } else if (es->region_posx > 0) {
4042 EDIT_MoveForward(es, TRUE);
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"))));
4207 EDIT_EM_Scroll(es, action);
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;
4228 vlc = get_vertical_line_count(es);
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;
4246 vlc = get_vertical_line_count(es);
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 */
4255 EDIT_UpdateScrollInfo(es);
4256 notify_parent(es, EN_VSCROLL);
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 */
4276 INT vlc = get_vertical_line_count(es);
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)
4293 EDIT_EM_LineScroll(es, 0, dy);
4294 return 0;
SB_BOTTOM
#define SB_BOTTOM
Definition: winuser.h:577
SB_TOP
#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 {
247 SCRIPT_ANALYSIS psa;
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;
ScriptBreak
HRESULT WINAPI ScriptBreak(const WCHAR *chars, int count, const SCRIPT_ANALYSIS *sa, SCRIPT_LOGATTR *la)
Definition: usp10.c:3047
psa
static SCRIPT_CACHE SCRIPT_ANALYSIS * psa
Definition: usp10.c:64
tag_SCRIPT_ANALYSIS
Definition: usp10.h:138
tag_SCRIPT_LOGATTR
Definition: usp10.h:186
SCRIPT_UNDEFINED
#define SCRIPT_UNDEFINED
Definition: usp10.h:69
WB_ISDELIMITER
#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)))
3805 return MAKELONG(EC_USEFONTINFO, EC_USEFONTINFO);
3806
3807 if (!is_cjk(hdc))
3808 return MAKELONG(EC_USEFONTINFO, EC_USEFONTINFO);
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);
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
abc
static UINT UINT LPWORD LPABC abc
Definition: font.c:44
SHORT
short SHORT
Definition: pedump.c:59
_ABC
Definition: wingdi.h:1410
_ABC::abcA
int abcA
Definition: wingdi.h:1411
_ABC::abcC
int abcC
Definition: wingdi.h:1413
GetCharABCWidthsW
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()

static UINT get_text_length ( EDITSTATE *  es)
inlinestatic

Definition at line 216 of file edit.c.

218{
219 if(es->text_length == (UINT)-1)
220 es->text_length = lstrlenW(es->text);
221 return es->text_length;

Referenced by EDIT_AdjustFormatRect(), EDIT_CharFromPos(), EDIT_EM_LineFromChar(), EDIT_EM_LineLength(), EDIT_EM_PosFromChar(), EDIT_EM_ReplaceSel(), EDIT_EM_ScrollCaret(), EDIT_EM_SetHandle(), EDIT_EM_SetSel(), EDIT_EM_SetWordBreakProc(), EDIT_InvalidateText(), EDIT_MoveEnd(), EDIT_UnlockBuffer(), EDIT_UpdateUniscribeData(), EDIT_WindowProc(), EDIT_WM_ContextMenu(), EDIT_WM_KeyDown(), EDIT_WM_SetFont(), and EDIT_WordBreakProc().

◆ 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;
str
const WCHAR * str
Definition: rpc_transport.c:2724

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{
2754 const DWORD FS_DBCS_MASK = FS_JISJAPAN|FS_CHINESESIMP|FS_WANSUNG|FS_CHINESETRAD|FS_JOHAB;
2755 FONTSIGNATURE fs;
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 }
fs
#define fs
Definition: i386-dis.c:444
fs
Definition: ffs.h:70
FS_JOHAB
#define FS_JOHAB
Definition: wingdi.h:574
GetTextCharsetInfo
int WINAPI GetTextCharsetInfo(_In_ HDC, _Out_opt_ LPFONTSIGNATURE, _In_ DWORD)
FS_WANSUNG
#define FS_WANSUNG
Definition: wingdi.h:572
DEFAULT_CHARSET
#define DEFAULT_CHARSET
Definition: wingdi.h:384
FS_JISJAPAN
#define FS_JISJAPAN
Definition: wingdi.h:570
FS_CHINESETRAD
#define FS_CHINESETRAD
Definition: wingdi.h:573
FS_CHINESESIMP
#define FS_CHINESESIMP
Definition: wingdi.h:571
GdiGetCodePage
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);
code
Definition: inflate.c:139
MAKEWPARAM
#define MAKEWPARAM(l, h)
Definition: winuser.h:4012
WM_COMMAND
#define WM_COMMAND
Definition: winuser.h:1743
GWLP_ID
#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;
1205 EDIT_InvalidateUniscribeData(es);

Referenced by EDIT_EM_ReplaceSel(), and EDIT_EM_SetHandle().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( edit  )