#include "editstr.h"

Include dependency graph for editor.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	RUN_IS_HIDDEN(run)

#define	InitFormatEtc(fe, cf, med)

#define	CP_UNICODE 1200

#define	TXTHOST_VTABLE(This) (This)->lpVtbl

#define	ITextHost_TxGetDC(This) TXTHOST_VTABLE(This)->TxGetDC(This)

#define	ITextHost_TxReleaseDC(This, a) TXTHOST_VTABLE(This)->TxReleaseDC(This,a)

#define	ITextHost_TxShowScrollBar(This, a, b) TXTHOST_VTABLE(This)->TxShowScrollBar(This,a,b)

#define	ITextHost_TxEnableScrollBar(This, a, b) TXTHOST_VTABLE(This)->TxEnableScrollBar(This,a,b)

#define	ITextHost_TxSetScrollRange(This, a, b, c, d) TXTHOST_VTABLE(This)->TxSetScrollRange(This,a,b,c,d)

#define	ITextHost_TxSetScrollPos(This, a, b, c) TXTHOST_VTABLE(This)->TxSetScrollPos(This,a,b,c)

#define	ITextHost_TxInvalidateRect(This, a, b) TXTHOST_VTABLE(This)->TxInvalidateRect(This,a,b)

#define	ITextHost_TxViewChange(This, a) TXTHOST_VTABLE(This)->TxViewChange(This,a)

#define	ITextHost_TxCreateCaret(This, a, b, c) TXTHOST_VTABLE(This)->TxCreateCaret(This,a,b,c)

#define	ITextHost_TxShowCaret(This, a) TXTHOST_VTABLE(This)->TxShowCaret(This,a)

#define	ITextHost_TxSetCaretPos(This, a, b) TXTHOST_VTABLE(This)->TxSetCaretPos(This,a,b)

#define	ITextHost_TxSetTimer(This, a, b) TXTHOST_VTABLE(This)->TxSetTimer(This,a,b)

#define	ITextHost_TxKillTimer(This, a) TXTHOST_VTABLE(This)->TxKillTimer(This,a)

#define	ITextHost_TxScrollWindowEx(This, a, b, c, d, e, f, g) TXTHOST_VTABLE(This)->TxScrollWindowEx(This,a,b,c,d,e,f,g)

#define	ITextHost_TxSetCapture(This, a) TXTHOST_VTABLE(This)->TxSetCapture(This,a)

#define	ITextHost_TxSetFocus(This) TXTHOST_VTABLE(This)->TxSetFocus(This)

#define	ITextHost_TxSetCursor(This, a, b) TXTHOST_VTABLE(This)->TxSetCursor(This,a,b)

#define	ITextHost_TxScreenToClient(This, a) TXTHOST_VTABLE(This)->TxScreenToClient(This,a)

#define	ITextHost_TxClientToScreen(This, a) TXTHOST_VTABLE(This)->TxClientToScreen(This,a)

#define	ITextHost_TxActivate(This, a) TXTHOST_VTABLE(This)->TxActivate(This,a)

#define	ITextHost_TxDeactivate(This, a) TXTHOST_VTABLE(This)->TxDeactivate(This,a)

#define	ITextHost_TxGetClientRect(This, a) TXTHOST_VTABLE(This)->TxGetClientRect(This,a)

#define	ITextHost_TxGetViewInset(This, a) TXTHOST_VTABLE(This)->TxGetViewInset(This,a)

#define	ITextHost_TxGetCharFormat(This, a) TXTHOST_VTABLE(This)->TxGetCharFormat(This,a)

#define	ITextHost_TxGetParaFormat(This, a) TXTHOST_VTABLE(This)->TxGetParaFormat(This,a)

#define	ITextHost_TxGetSysColor(This, a) TXTHOST_VTABLE(This)->TxGetSysColor(This,a)

#define	ITextHost_TxGetBackStyle(This, a) TXTHOST_VTABLE(This)->TxGetBackStyle(This,a)

#define	ITextHost_TxGetMaxLength(This, a) TXTHOST_VTABLE(This)->TxGetMaxLength(This,a)

#define	ITextHost_TxGetScrollBars(This, a) TXTHOST_VTABLE(This)->TxGetScrollBars(This,a)

#define	ITextHost_TxGetPasswordChar(This, a) TXTHOST_VTABLE(This)->TxGetPasswordChar(This,a)

#define	ITextHost_TxGetAcceleratorPos(This, a) TXTHOST_VTABLE(This)->TxGetAcceleratorPos(This,a)

#define	ITextHost_TxGetExtent(This, a) TXTHOST_VTABLE(This)->TxGetExtent(This,a)

#define	ITextHost_OnTxCharFormatChange(This, a) TXTHOST_VTABLE(This)->OnTxCharFormatChange(This,a)

#define	ITextHost_OnTxParaFormatChange(This, a) TXTHOST_VTABLE(This)->OnTxParaFormatChange(This,a)

#define	ITextHost_TxGetPropertyBits(This, a, b) TXTHOST_VTABLE(This)->TxGetPropertyBits(This,a,b)

#define	ITextHost_TxNotify(This, a, b) TXTHOST_VTABLE(This)->TxNotify(This,a,b)

#define	ITextHost_TxImmGetContext(This) TXTHOST_VTABLE(This)->TxImmGetContext(This)

#define	ITextHost_TxImmReleaseContext(This, a) TXTHOST_VTABLE(This)->TxImmReleaseContext(This,a)

#define	ITextHost_TxGetSelectionBarWidth(This, a) TXTHOST_VTABLE(This)->TxGetSelectionBarWidth(This,a)

#define	ITextHost2_TxIsDoubleClickPending(This) TXTHOST_VTABLE(This)->TxIsDoubleClickPending(This)

#define	ITextHost2_TxGetWindow(This, a) TXTHOST_VTABLE(This)->TxGetWindow(This,a)

#define	ITextHost2_TxSetForegroundWindow(This) TXTHOST_VTABLE(This)->TxSetForegroundWindow(This)

#define	ITextHost2_TxGetPalette(This) TXTHOST_VTABLE(This)->TxGetPalette(This)

#define	ITextHost2_TxGetEastAsianFlags(This, a) TXTHOST_VTABLE(This)->TxGetEastAsianFlags(This,a)

#define	ITextHost2_TxSetCursor2(This, a, b) TXTHOST_VTABLE(This)->TxSetCursor2(This,a,b)

#define	ITextHost2_TxFreeTextServicesNotification(This) TXTHOST_VTABLE(This)->TxFreeTextServicesNotification(This)

#define	ITextHost2_TxGetEditStyle(This, a, b) TXTHOST_VTABLE(This)->TxGetEditStyle(This,a,b)

#define	ITextHost2_TxGetWindowStyles(This, a, b) TXTHOST_VTABLE(This)->TxGetWindowStyles(This,a,b)

#define	ITextHost2_TxShowDropCaret(This, a, b, c) TXTHOST_VTABLE(This)->TxShowDropCaret(This,a,b,c)

#define	ITextHost2_TxDestroyCaret(This) TXTHOST_VTABLE(This)->TxDestroyCaret(This)

#define	ITextHost2_TxGetHorzExtent(This, a) TXTHOST_VTABLE(This)->TxGetHorzExtent(This,a)

#define	TXTSERV_VTABLE(This) (This)->lpVtbl

#define	ITextServices_TxSendMessage(This, a, b, c, d) TXTSERV_VTABLE(This)->TxSendMessage(This,a,b,c,d)

#define	ITextServices_TxDraw(This, a, b, c, d, e, f, g, h, i, j, k, l) TXTSERV_VTABLE(This)->TxDraw(This,a,b,c,d,e,f,g,h,i,j,k,l)

#define	ITextServices_TxGetHScroll(This, a, b, c, d, e) TXTSERV_VTABLE(This)->TxGetHScroll(This,a,b,c,d,e)

#define	ITextServices_TxGetVScroll(This, a, b, c, d, e) TXTSERV_VTABLE(This)->TxGetVScroll(This,a,b,c,d,e)

#define	ITextServices_OnTxSetCursor(This, a, b, c, d, e, f, g, h, i) TXTSERV_VTABLE(This)->OnTxSetCursor(This,a,b,c,d,e,f,g,h,i)

#define	ITextServices_TxQueryHitPoint(This, a, b, c, d, e, f, g, h, i, j) TXTSERV_VTABLE(This)->TxQueryHitPoint(This,a,b,c,d,e,f,g,h,i,j)

#define	ITextServices_OnTxInPlaceActivate(This, a) TXTSERV_VTABLE(This)->OnTxInPlaceActivate(This,a)

#define	ITextServices_OnTxInPlaceDeactivate(This) TXTSERV_VTABLE(This)->OnTxInPlaceDeactivate(This)

#define	ITextServices_OnTxUIActivate(This) TXTSERV_VTABLE(This)->OnTxUIActivate(This)

#define	ITextServices_OnTxUIDeactivate(This) TXTSERV_VTABLE(This)->OnTxUIDeactivate(This)

#define	ITextServices_TxGetText(This, a) TXTSERV_VTABLE(This)->TxGetText(This,a)

#define	ITextServices_TxSetText(This, a) TXTSERV_VTABLE(This)->TxSetText(This,a)

#define	ITextServices_TxGetCurTargetX(This, a) TXTSERV_VTABLE(This)->TxGetCurTargetX(This,a)

#define	ITextServices_TxGetBaseLinePos(This, a) TXTSERV_VTABLE(This)->TxGetBaseLinePos(This,a)

#define	ITextServices_TxGetNaturalSize(This, a, b, c, d, e, f, g, h) TXTSERV_VTABLE(This)->TxGetNaturalSize(This,a,b,c,d,e,f,g,h)

#define	ITextServices_TxGetDropTarget(This, a) TXTSERV_VTABLE(This)->TxGetDropTarget(This,a)

#define	ITextServices_OnTxPropertyBitsChange(This, a, b) TXTSERV_VTABLE(This)->OnTxPropertyBitsChange(This,a,b)

#define	ITextServices_TxGetCachedSize(This, a, b) TXTSERV_VTABLE(This)->TxGetCachedSize(This,a,b)

Functions
static WCHAR *	get_text (const ME_Run *run, int offset)

static const char *	debugstr_run (const ME_Run *run)

ME_Style *	style_get_insert_style (ME_TextEditor editor, ME_Cursor cursor) DECLSPEC_HIDDEN

ME_Style *	ME_MakeStyle (CHARFORMAT2W *style) DECLSPEC_HIDDEN

void	ME_AddRefStyle (ME_Style *item) DECLSPEC_HIDDEN

void	ME_DestroyStyle (ME_Style *item) DECLSPEC_HIDDEN

void	ME_ReleaseStyle (ME_Style *item) DECLSPEC_HIDDEN

ME_Style *	ME_ApplyStyle (ME_TextEditor ed, ME_Style sSrc, CHARFORMAT2W *style) DECLSPEC_HIDDEN

void	select_style (ME_Context c, ME_Style s) DECLSPEC_HIDDEN

void	ME_InitCharFormat2W (CHARFORMAT2W *pFmt) DECLSPEC_HIDDEN

void	ME_SaveTempStyle (ME_TextEditor editor, ME_Style style) DECLSPEC_HIDDEN

void	ME_ClearTempStyle (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_DumpStyleToBuf (CHARFORMAT2W *pFmt, char buf[2048]) DECLSPEC_HIDDEN

void	ME_DumpStyle (ME_Style *s) DECLSPEC_HIDDEN

BOOL	cfany_to_cf2w (CHARFORMAT2W to, const CHARFORMAT2W from) DECLSPEC_HIDDEN

BOOL	cf2w_to_cfany (CHARFORMAT2W to, const CHARFORMAT2W from) DECLSPEC_HIDDEN

void	ME_CopyCharFormat (CHARFORMAT2W pDest, const CHARFORMAT2W pSrc) DECLSPEC_HIDDEN

void	ME_CharFormatFromLogFont (HDC hDC, const LOGFONTW lf, CHARFORMAT2W fmt) DECLSPEC_HIDDEN

void	ME_InsertBefore (ME_DisplayItem diWhere, ME_DisplayItem diWhat) DECLSPEC_HIDDEN

void	ME_Remove (ME_DisplayItem *diWhere) DECLSPEC_HIDDEN

ME_DisplayItem *	ME_FindItemBack (ME_DisplayItem *di, ME_DIType nTypeOrClass) DECLSPEC_HIDDEN

ME_DisplayItem *	ME_FindItemFwd (ME_DisplayItem *di, ME_DIType nTypeOrClass) DECLSPEC_HIDDEN

ME_DisplayItem *	ME_FindItemBackOrHere (ME_DisplayItem *di, ME_DIType nTypeOrClass) DECLSPEC_HIDDEN

ME_DisplayItem *	ME_MakeDI (ME_DIType type) DECLSPEC_HIDDEN

void	ME_DestroyDisplayItem (ME_DisplayItem *item) DECLSPEC_HIDDEN

void	ME_DumpDocument (ME_TextBuffer *buffer) DECLSPEC_HIDDEN

ME_String *	ME_MakeStringN (LPCWSTR szText, int nMaxChars) DECLSPEC_HIDDEN

ME_String *	ME_MakeStringR (WCHAR cRepeat, int nMaxChars) DECLSPEC_HIDDEN

ME_String *	ME_MakeStringConst (const WCHAR *str, int len) DECLSPEC_HIDDEN

ME_String *	ME_MakeStringEmpty (int len) DECLSPEC_HIDDEN

void	ME_DestroyString (ME_String *s) DECLSPEC_HIDDEN

BOOL	ME_AppendString (ME_String s, const WCHAR append, int len) DECLSPEC_HIDDEN

ME_String *	ME_VSplitString (ME_String *orig, int nVPos) DECLSPEC_HIDDEN

int	ME_FindNonWhitespaceV (const ME_String *s, int nVChar) DECLSPEC_HIDDEN

int	ME_CallWordBreakProc (ME_TextEditor editor, WCHAR str, INT len, INT start, INT code) DECLSPEC_HIDDEN

void	ME_StrDeleteV (ME_String *s, int nVChar, int nChars) DECLSPEC_HIDDEN

BOOL	ME_InsertString (ME_String s, int ofs, const WCHAR insert, int len) DECLSPEC_HIDDEN

LPWSTR	ME_ToUnicode (LONG codepage, LPVOID psz, INT *len) DECLSPEC_HIDDEN

void	ME_EndToUnicode (LONG codepage, LPVOID psz) DECLSPEC_HIDDEN

static int	ME_IsWSpace (WCHAR ch)

static int	ME_CharCompare (WCHAR a, WCHAR b, int caseSensitive)

int	ME_ReverseFindNonWhitespaceV (const ME_String *s, int nVChar) DECLSPEC_HIDDEN

int	ME_ReverseFindWhitespaceV (const ME_String *s, int nVChar) DECLSPEC_HIDDEN

void	row_end_cursor (ME_Row row, ME_Cursor cursor, BOOL include_eop) DECLSPEC_HIDDEN

void	row_first_cursor (ME_Row row, ME_Cursor cursor) DECLSPEC_HIDDEN

ME_Run *	row_first_run (ME_Row *row) DECLSPEC_HIDDEN

ME_Row *	row_from_cursor (ME_Cursor *cursor) DECLSPEC_HIDDEN

ME_Row *	row_from_row_number (ME_TextEditor *editor, int row_num) DECLSPEC_HIDDEN

ME_Row *	row_next (ME_Row *row) DECLSPEC_HIDDEN

ME_Row *	row_next_all_paras (ME_Row *row) DECLSPEC_HIDDEN

ME_Run *	row_next_run (ME_Row row, ME_Run run) DECLSPEC_HIDDEN

int	row_number_from_char_ofs (ME_TextEditor *editor, int ofs) DECLSPEC_HIDDEN

ME_Paragraph *	row_para (ME_Row *row) DECLSPEC_HIDDEN

ME_Row *	row_prev_all_paras (ME_Row *row) DECLSPEC_HIDDEN

static ME_DisplayItem *	row_get_di (ME_Row *row)

void	cursor_from_char_ofs (ME_TextEditor editor, int char_ofs, ME_Cursor cursor) DECLSPEC_HIDDEN

BOOL	cursor_next_run (ME_Cursor *cursor, BOOL all_para) DECLSPEC_HIDDEN

BOOL	cursor_prev_run (ME_Cursor *cursor, BOOL all_para) DECLSPEC_HIDDEN

void	editor_propagate_char_ofs (ME_Paragraph para, ME_Run run, int shift) DECLSPEC_HIDDEN

int	run_char_ofs (ME_Run *run, int ofs) DECLSPEC_HIDDEN

ME_Run *	run_create (ME_Style *s, int nFlags) DECLSPEC_HIDDEN

ME_Run *	run_insert (ME_TextEditor editor, ME_Cursor cursor, ME_Style style, const WCHAR str, int len, int flags) DECLSPEC_HIDDEN

void	ME_CheckCharOffsets (ME_TextEditor *editor) DECLSPEC_HIDDEN

int	ME_CharFromPointContext (ME_Context c, int cx, ME_Run run, BOOL closest, BOOL visual_order) DECLSPEC_HIDDEN

int	ME_CharFromPoint (ME_TextEditor editor, int cx, ME_Run run, BOOL closest, BOOL visual_order) DECLSPEC_HIDDEN

int	ME_PointFromCharContext (ME_Context c, ME_Run pRun, int nOffset, BOOL visual_order) DECLSPEC_HIDDEN

int	ME_PointFromChar (ME_TextEditor editor, ME_Run pRun, int nOffset, BOOL visual_order) DECLSPEC_HIDDEN

BOOL	ME_CanJoinRuns (const ME_Run run1, const ME_Run run2) DECLSPEC_HIDDEN

void	run_join (ME_TextEditor editor, ME_Run run) DECLSPEC_HIDDEN

ME_Run *	run_next (ME_Run *run) DECLSPEC_HIDDEN

ME_Run *	run_next_all_paras (ME_Run *run) DECLSPEC_HIDDEN

ME_Run *	run_prev (ME_Run *run) DECLSPEC_HIDDEN

ME_Run *	run_prev_all_paras (ME_Run *run) DECLSPEC_HIDDEN

ME_Run *	run_split (ME_TextEditor editor, ME_Cursor cursor) DECLSPEC_HIDDEN

void	ME_UpdateRunFlags (ME_TextEditor editor, ME_Run run) DECLSPEC_HIDDEN

SIZE	ME_GetRunSizeCommon (ME_Context c, const ME_Paragraph para, ME_Run run, int nLen, int startx, int pAscent, int *pDescent) DECLSPEC_HIDDEN

void	ME_SetCharFormat (ME_TextEditor editor, ME_Cursor start, ME_Cursor end, CHARFORMAT2W pFmt) DECLSPEC_HIDDEN

void	ME_SetSelectionCharFormat (ME_TextEditor editor, CHARFORMAT2W pFmt) DECLSPEC_HIDDEN

void	ME_GetCharFormat (ME_TextEditor editor, const ME_Cursor from, const ME_Cursor to, CHARFORMAT2W pFmt) DECLSPEC_HIDDEN

void	ME_GetSelectionCharFormat (ME_TextEditor editor, CHARFORMAT2W pFmt) DECLSPEC_HIDDEN

void	ME_GetDefaultCharFormat (ME_TextEditor editor, CHARFORMAT2W pFmt) DECLSPEC_HIDDEN

void	ME_SetDefaultCharFormat (ME_TextEditor editor, CHARFORMAT2W mod) DECLSPEC_HIDDEN

static ME_DisplayItem *	run_get_di (ME_Run *run)

void	cursor_coords (ME_TextEditor editor, ME_Cursor cursor, int x, int y, int *height) DECLSPEC_HIDDEN

void	ME_SetCursorToStart (ME_TextEditor editor, ME_Cursor cursor) DECLSPEC_HIDDEN

int	set_selection_cursors (ME_TextEditor *editor, int from, int to) DECLSPEC_HIDDEN

BOOL	ME_MoveCursorWords (ME_TextEditor editor, ME_Cursor cursor, int nRelOfs) DECLSPEC_HIDDEN

void	hide_caret (ME_TextEditor *ed) DECLSPEC_HIDDEN

void	show_caret (ME_TextEditor *ed) DECLSPEC_HIDDEN

void	update_caret (ME_TextEditor *ed) DECLSPEC_HIDDEN

void	create_caret (ME_TextEditor *ed) DECLSPEC_HIDDEN

BOOL	ME_CharFromPos (ME_TextEditor editor, int x, int y, ME_Cursor cursor, BOOL *isExact) DECLSPEC_HIDDEN

void	ME_LButtonDown (ME_TextEditor *editor, int x, int y, int clickNum) DECLSPEC_HIDDEN

void	ME_MouseMove (ME_TextEditor *editor, int x, int y) DECLSPEC_HIDDEN

BOOL	ME_DeleteTextAtCursor (ME_TextEditor *editor, int nCursor, int nChars) DECLSPEC_HIDDEN

void	ME_InsertTextFromCursor (ME_TextEditor editor, int nCursor, const WCHAR str, int len, ME_Style *style) DECLSPEC_HIDDEN

void	ME_InsertEndRowFromCursor (ME_TextEditor *editor, int nCursor) DECLSPEC_HIDDEN

int	ME_MoveCursorChars (ME_TextEditor editor, ME_Cursor cursor, int nRelOfs, BOOL final_eop) DECLSPEC_HIDDEN

BOOL	ME_ArrowKey (ME_TextEditor *ed, int nVKey, BOOL extend, BOOL ctrl) DECLSPEC_HIDDEN

int	ME_GetCursorOfs (const ME_Cursor *cursor) DECLSPEC_HIDDEN

int	ME_GetSelectionOfs (ME_TextEditor editor, int from, int *to) DECLSPEC_HIDDEN

int	ME_GetSelection (ME_TextEditor editor, ME_Cursor from, ME_Cursor *to) DECLSPEC_HIDDEN

BOOL	ME_IsSelection (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_DeleteSelection (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_SendSelChange (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_InsertOLEFromCursor (ME_TextEditor editor, const REOBJECT reo, int nCursor) DECLSPEC_HIDDEN

BOOL	ME_InternalDeleteText (ME_TextEditor editor, ME_Cursor start, int nChars, BOOL bForce) DECLSPEC_HIDDEN

int	ME_GetTextLength (ME_TextEditor *editor) DECLSPEC_HIDDEN

int	ME_GetTextLengthEx (ME_TextEditor editor, const GETTEXTLENGTHEX how) DECLSPEC_HIDDEN

ME_Style *	ME_GetSelectionInsertStyle (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_InitContext (ME_Context c, ME_TextEditor editor, HDC hDC) DECLSPEC_HIDDEN

void	ME_DestroyContext (ME_Context *c) DECLSPEC_HIDDEN

BOOL	ME_WrapMarkedParagraphs (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	para_range_invalidate (ME_TextEditor editor, ME_Paragraph start_para, ME_Paragraph *last_para) DECLSPEC_HIDDEN

void	ME_SendRequestResize (ME_TextEditor *editor, BOOL force) DECLSPEC_HIDDEN

BOOL	wrap_marked_paras_dc (ME_TextEditor *editor, HDC hdc, BOOL invalidate) DECLSPEC_HIDDEN

void	editor_get_selection_paras (ME_TextEditor editor, ME_Paragraph para, ME_Paragraph *para_end) DECLSPEC_HIDDEN

void	editor_get_selection_para_fmt (ME_TextEditor editor, PARAFORMAT2 fmt) DECLSPEC_HIDDEN

void	editor_mark_rewrap_all (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	editor_set_default_para_fmt (ME_TextEditor editor, PARAFORMAT2 pFmt) DECLSPEC_HIDDEN

BOOL	editor_set_selection_para_fmt (ME_TextEditor editor, const PARAFORMAT2 fmt) DECLSPEC_HIDDEN

void	ME_MakeFirstParagraph (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_DumpParaStyle (ME_Paragraph *s) DECLSPEC_HIDDEN

void	ME_DumpParaStyleToBuf (const PARAFORMAT2 *pFmt, char buf[2048]) DECLSPEC_HIDDEN

int	get_total_width (ME_TextEditor *editor) DECLSPEC_HIDDEN

ME_Cell *	para_cell (ME_Paragraph *para) DECLSPEC_HIDDEN

void	para_destroy (ME_TextEditor editor, ME_Paragraph item) DECLSPEC_HIDDEN

ME_Row *	para_end_row (ME_Paragraph *para) DECLSPEC_HIDDEN

ME_Run *	para_end_run (ME_Paragraph *para) DECLSPEC_HIDDEN

ME_Row *	para_first_row (ME_Paragraph *para) DECLSPEC_HIDDEN

ME_Run *	para_first_run (ME_Paragraph *para) DECLSPEC_HIDDEN

BOOL	para_in_table (ME_Paragraph *para) DECLSPEC_HIDDEN

ME_Paragraph *	para_join (ME_TextEditor editor, ME_Paragraph para, BOOL use_first_fmt) DECLSPEC_HIDDEN

void	para_mark_add (ME_TextEditor editor, ME_Paragraph para) DECLSPEC_HIDDEN

void	para_mark_remove (ME_TextEditor editor, ME_Paragraph para) DECLSPEC_HIDDEN

void	para_mark_rewrap (ME_TextEditor editor, ME_Paragraph para) DECLSPEC_HIDDEN

ME_Paragraph *	para_next (ME_Paragraph *para) DECLSPEC_HIDDEN

void	para_num_clear (struct para_num *pn) DECLSPEC_HIDDEN

void	para_num_init (ME_Context c, ME_Paragraph para) DECLSPEC_HIDDEN

ME_Paragraph *	para_prev (ME_Paragraph *para) DECLSPEC_HIDDEN

ME_Paragraph *	para_split (ME_TextEditor editor, ME_Run run, ME_Style style, const WCHAR eol_str, int eol_len, int paraFlags) DECLSPEC_HIDDEN

static ME_DisplayItem *	para_get_di (ME_Paragraph *para)

void	editor_draw (ME_TextEditor editor, HDC hDC, const RECT update) DECLSPEC_HIDDEN

void	ME_Repaint (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_RewrapRepaint (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_UpdateRepaint (ME_TextEditor *editor, BOOL update_now) DECLSPEC_HIDDEN

void	editor_ensure_visible (ME_TextEditor editor, ME_Cursor cursor) DECLSPEC_HIDDEN

void	ME_InvalidateSelection (ME_TextEditor *editor) DECLSPEC_HIDDEN

BOOL	ME_SetZoom (ME_TextEditor *editor, int numerator, int denominator) DECLSPEC_HIDDEN

int	ME_twips2pointsX (const ME_Context *c, int x) DECLSPEC_HIDDEN

int	ME_twips2pointsY (const ME_Context *c, int y) DECLSPEC_HIDDEN

void	scroll_abs (ME_TextEditor *editor, int x, int y, BOOL notify) DECLSPEC_HIDDEN

void	scroll_h_abs (ME_TextEditor *editor, int x, BOOL notify) DECLSPEC_HIDDEN

void	scroll_v_abs (ME_TextEditor *editor, int y, BOOL notify) DECLSPEC_HIDDEN

void	ME_ScrollUp (ME_TextEditor *editor, int cy) DECLSPEC_HIDDEN

void	ME_ScrollDown (ME_TextEditor *editor, int cy) DECLSPEC_HIDDEN

void	ME_ScrollLeft (ME_TextEditor *editor, int cx) DECLSPEC_HIDDEN

void	ME_ScrollRight (ME_TextEditor *editor, int cx) DECLSPEC_HIDDEN

void	ME_UpdateScrollBar (ME_TextEditor *editor) DECLSPEC_HIDDEN

int	ME_GetParaBorderWidth (const ME_Context *c, int flags) DECLSPEC_HIDDEN

void	draw_ole (ME_Context c, int x, int y, ME_Run run, BOOL selected) DECLSPEC_HIDDEN

void	ME_GetOLEObjectSize (const ME_Context c, ME_Run run, SIZE *pSize) DECLSPEC_HIDDEN

void	ME_CopyReObject (REOBJECT dst, const REOBJECT src, DWORD flags) DECLSPEC_HIDDEN

void	ME_DeleteReObject (struct re_object *re_object) DECLSPEC_HIDDEN

void	richole_release_children (struct text_services *services) DECLSPEC_HIDDEN

ME_TextEditor *	ME_MakeEditor (ITextHost *texthost, BOOL bEmulateVersion10) DECLSPEC_HIDDEN

void	ME_DestroyEditor (ME_TextEditor *editor) DECLSPEC_HIDDEN

LRESULT	editor_handle_message (ME_TextEditor editor, UINT msg, WPARAM wParam, LPARAM lParam, HRESULT phresult) DECLSPEC_HIDDEN

int	ME_GetTextW (ME_TextEditor editor, WCHAR buffer, int buflen, const ME_Cursor *start, int srcChars, BOOL bCRLF, BOOL bEOP) DECLSPEC_HIDDEN

void	ME_RTFCharAttrHook (struct _RTF_Info *info) DECLSPEC_HIDDEN

void	ME_RTFParAttrHook (struct _RTF_Info *info) DECLSPEC_HIDDEN

void	ME_RTFTblAttrHook (struct _RTF_Info *info) DECLSPEC_HIDDEN

void	ME_RTFSpecialCharHook (struct _RTF_Info *info) DECLSPEC_HIDDEN

void	ME_StreamInFill (ME_InStream *stream) DECLSPEC_HIDDEN

void	ME_ReplaceSel (ME_TextEditor editor, BOOL can_undo, const WCHAR str, int len) DECLSPEC_HIDDEN

int	set_selection (ME_TextEditor *editor, int to, int from) DECLSPEC_HIDDEN

HRESULT	editor_copy_or_cut (ME_TextEditor editor, BOOL cut, ME_Cursor start, int count, IDataObject **data_out) DECLSPEC_HIDDEN

ME_Paragraph *	editor_end_para (ME_TextEditor *editor) DECLSPEC_HIDDEN

ME_Paragraph *	editor_first_para (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	editor_set_cursor (ME_TextEditor *editor, int x, int y) DECLSPEC_HIDDEN

void	link_notify (ME_TextEditor *editor, UINT msg, WPARAM wParam, LPARAM lParam) DECLSPEC_HIDDEN

ME_Cell *	cell_create (void) DECLSPEC_HIDDEN

ME_Paragraph *	cell_end_para (ME_Cell *cell) DECLSPEC_HIDDEN

ME_Paragraph *	cell_first_para (ME_Cell *cell) DECLSPEC_HIDDEN

ME_Cell *	cell_next (ME_Cell *cell) DECLSPEC_HIDDEN

ME_Cell *	cell_prev (ME_Cell *cell) DECLSPEC_HIDDEN

ME_Paragraph *	table_append_row (ME_TextEditor editor, ME_Paragraph table_row) DECLSPEC_HIDDEN

void	table_handle_tab (ME_TextEditor *editor, BOOL selected_row) DECLSPEC_HIDDEN

ME_Paragraph *	table_insert_cell (ME_TextEditor editor, ME_Cursor cursor) DECLSPEC_HIDDEN

ME_Paragraph *	table_insert_row_end (ME_TextEditor editor, ME_Cursor cursor) DECLSPEC_HIDDEN

ME_Paragraph *	table_insert_row_start (ME_TextEditor editor, ME_Cursor cursor) DECLSPEC_HIDDEN

ME_Paragraph *	table_insert_row_start_at_para (ME_TextEditor editor, ME_Paragraph para) DECLSPEC_HIDDEN

void	table_move_from_row_start (ME_TextEditor *editor) DECLSPEC_HIDDEN

ME_Paragraph *	table_outer_para (ME_Paragraph *para) DECLSPEC_HIDDEN

void	table_protect_partial_deletion (ME_TextEditor editor, ME_Cursor c, int *num_chars) DECLSPEC_HIDDEN

ME_Paragraph *	table_row_end (ME_Paragraph *para) DECLSPEC_HIDDEN

ME_Cell *	table_row_end_cell (ME_Paragraph *para) DECLSPEC_HIDDEN

ME_Cell *	table_row_first_cell (ME_Paragraph *para) DECLSPEC_HIDDEN

ME_Paragraph *	table_row_start (ME_Paragraph *para) DECLSPEC_HIDDEN

struct RTFTable *	ME_MakeTableDef (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_InitTableDef (ME_TextEditor editor, struct RTFTable tableDef) DECLSPEC_HIDDEN

static ME_DisplayItem *	cell_get_di (ME_Cell *cell)

BOOL	add_undo_insert_run (ME_TextEditor , int pos, const WCHAR str, int len, int flags, ME_Style *style) DECLSPEC_HIDDEN

BOOL	add_undo_delete_run (ME_TextEditor *, int pos, int len) DECLSPEC_HIDDEN

BOOL	add_undo_set_para_fmt (ME_TextEditor , const ME_Paragraph para) DECLSPEC_HIDDEN

BOOL	add_undo_set_char_fmt (ME_TextEditor , int pos, int len, const CHARFORMAT2W fmt) DECLSPEC_HIDDEN

BOOL	add_undo_join_paras (ME_TextEditor *, int pos) DECLSPEC_HIDDEN

BOOL	add_undo_split_para (ME_TextEditor , const ME_Paragraph para, ME_String eol_str, const ME_Cell cell) DECLSPEC_HIDDEN

void	ME_CommitUndo (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_ContinueCoalescingTransaction (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_CommitCoalescingUndo (ME_TextEditor *editor) DECLSPEC_HIDDEN

BOOL	ME_Undo (ME_TextEditor *editor) DECLSPEC_HIDDEN

BOOL	ME_Redo (ME_TextEditor *editor) DECLSPEC_HIDDEN

void	ME_EmptyUndoStack (ME_TextEditor *editor) DECLSPEC_HIDDEN

HRESULT	create_text_services (IUnknown outer, ITextHost text_host, IUnknown **unk, BOOL emulate_10) DECLSPEC_HIDDEN

LRESULT	ME_StreamOutRange (ME_TextEditor editor, DWORD dwFormat, const ME_Cursor start, int nChars, EDITSTREAM *stream) DECLSPEC_HIDDEN

LRESULT	ME_StreamOut (ME_TextEditor editor, DWORD dwFormat, EDITSTREAM stream) DECLSPEC_HIDDEN

HRESULT	ME_GetDataObject (ME_TextEditor editor, const ME_Cursor start, int nChars, LPDATAOBJECT *lplpdataobj) DECLSPEC_HIDDEN

void	release_typelib (void) DECLSPEC_HIDDEN

Variables
HINSTANCE dll_instance	DECLSPEC_HIDDEN

Macro Definition Documentation

◆ CP_UNICODE

#define CP_UNICODE 1200

Definition at line 93 of file editor.h.

◆ InitFormatEtc

#define InitFormatEtc	(	fe,
		cf,
		med
	)

Value:

        {\
        (fe).cfFormat=cf;\
        (fe).dwAspect=DVASPECT_CONTENT;\
        (fe).ptd=NULL;\
        (fe).tymed=med;\
        (fe).lindex=-1;\
        };

Definition at line 33 of file editor.h.

◆ ITextHost2_TxDestroyCaret

#define ITextHost2_TxDestroyCaret ( This ) TXTHOST_VTABLE(This)->TxDestroyCaret(This)

Definition at line 383 of file editor.h.

◆ ITextHost2_TxFreeTextServicesNotification

#define ITextHost2_TxFreeTextServicesNotification ( This ) TXTHOST_VTABLE(This)->TxFreeTextServicesNotification(This)

Definition at line 379 of file editor.h.

◆ ITextHost2_TxGetEastAsianFlags

#define ITextHost2_TxGetEastAsianFlags	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetEastAsianFlags(This,a)

Definition at line 377 of file editor.h.

◆ ITextHost2_TxGetEditStyle

#define ITextHost2_TxGetEditStyle	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxGetEditStyle(This,a,b)

Definition at line 380 of file editor.h.

◆ ITextHost2_TxGetHorzExtent

#define ITextHost2_TxGetHorzExtent	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetHorzExtent(This,a)

Definition at line 384 of file editor.h.

◆ ITextHost2_TxGetPalette

#define ITextHost2_TxGetPalette ( This ) TXTHOST_VTABLE(This)->TxGetPalette(This)

Definition at line 376 of file editor.h.

◆ ITextHost2_TxGetWindow

#define ITextHost2_TxGetWindow	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetWindow(This,a)

Definition at line 374 of file editor.h.

◆ ITextHost2_TxGetWindowStyles

#define ITextHost2_TxGetWindowStyles	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxGetWindowStyles(This,a,b)

Definition at line 381 of file editor.h.

◆ ITextHost2_TxIsDoubleClickPending

#define ITextHost2_TxIsDoubleClickPending ( This ) TXTHOST_VTABLE(This)->TxIsDoubleClickPending(This)

Definition at line 373 of file editor.h.

◆ ITextHost2_TxSetCursor2

#define ITextHost2_TxSetCursor2	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxSetCursor2(This,a,b)

Definition at line 378 of file editor.h.

◆ ITextHost2_TxSetForegroundWindow

#define ITextHost2_TxSetForegroundWindow ( This ) TXTHOST_VTABLE(This)->TxSetForegroundWindow(This)

Definition at line 375 of file editor.h.

◆ ITextHost2_TxShowDropCaret

#define ITextHost2_TxShowDropCaret	(	This,
		a,
		b,
		c
	)	TXTHOST_VTABLE(This)->TxShowDropCaret(This,a,b,c)

Definition at line 382 of file editor.h.

◆ ITextHost_OnTxCharFormatChange

#define ITextHost_OnTxCharFormatChange	(	This,
		a
	)	TXTHOST_VTABLE(This)->OnTxCharFormatChange(This,a)

Definition at line 365 of file editor.h.

◆ ITextHost_OnTxParaFormatChange

#define ITextHost_OnTxParaFormatChange	(	This,
		a
	)	TXTHOST_VTABLE(This)->OnTxParaFormatChange(This,a)

Definition at line 366 of file editor.h.

◆ ITextHost_TxActivate

#define ITextHost_TxActivate	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxActivate(This,a)

Definition at line 352 of file editor.h.

◆ ITextHost_TxClientToScreen

#define ITextHost_TxClientToScreen	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxClientToScreen(This,a)

Definition at line 351 of file editor.h.

◆ ITextHost_TxCreateCaret

#define ITextHost_TxCreateCaret	(	This,
		a,
		b,
		c
	)	TXTHOST_VTABLE(This)->TxCreateCaret(This,a,b,c)

Definition at line 341 of file editor.h.

◆ ITextHost_TxDeactivate

#define ITextHost_TxDeactivate	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxDeactivate(This,a)

Definition at line 353 of file editor.h.

◆ ITextHost_TxEnableScrollBar

#define ITextHost_TxEnableScrollBar	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxEnableScrollBar(This,a,b)

Definition at line 336 of file editor.h.

◆ ITextHost_TxGetAcceleratorPos

#define ITextHost_TxGetAcceleratorPos	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetAcceleratorPos(This,a)

Definition at line 363 of file editor.h.

◆ ITextHost_TxGetBackStyle

#define ITextHost_TxGetBackStyle	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetBackStyle(This,a)

Definition at line 359 of file editor.h.

◆ ITextHost_TxGetCharFormat

#define ITextHost_TxGetCharFormat	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetCharFormat(This,a)

Definition at line 356 of file editor.h.

◆ ITextHost_TxGetClientRect

#define ITextHost_TxGetClientRect	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetClientRect(This,a)

Definition at line 354 of file editor.h.

◆ ITextHost_TxGetDC

#define ITextHost_TxGetDC ( This ) TXTHOST_VTABLE(This)->TxGetDC(This)

Definition at line 333 of file editor.h.

◆ ITextHost_TxGetExtent

#define ITextHost_TxGetExtent	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetExtent(This,a)

Definition at line 364 of file editor.h.

◆ ITextHost_TxGetMaxLength

#define ITextHost_TxGetMaxLength	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetMaxLength(This,a)

Definition at line 360 of file editor.h.

◆ ITextHost_TxGetParaFormat

#define ITextHost_TxGetParaFormat	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetParaFormat(This,a)

Definition at line 357 of file editor.h.

◆ ITextHost_TxGetPasswordChar

#define ITextHost_TxGetPasswordChar	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetPasswordChar(This,a)

Definition at line 362 of file editor.h.

◆ ITextHost_TxGetPropertyBits

#define ITextHost_TxGetPropertyBits	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxGetPropertyBits(This,a,b)

Definition at line 367 of file editor.h.

◆ ITextHost_TxGetScrollBars

#define ITextHost_TxGetScrollBars	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetScrollBars(This,a)

Definition at line 361 of file editor.h.

◆ ITextHost_TxGetSelectionBarWidth

#define ITextHost_TxGetSelectionBarWidth	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetSelectionBarWidth(This,a)

Definition at line 371 of file editor.h.

◆ ITextHost_TxGetSysColor

#define ITextHost_TxGetSysColor	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetSysColor(This,a)

Definition at line 358 of file editor.h.

◆ ITextHost_TxGetViewInset

#define ITextHost_TxGetViewInset	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxGetViewInset(This,a)

Definition at line 355 of file editor.h.

◆ ITextHost_TxImmGetContext

#define ITextHost_TxImmGetContext ( This ) TXTHOST_VTABLE(This)->TxImmGetContext(This)

Definition at line 369 of file editor.h.

◆ ITextHost_TxImmReleaseContext

#define ITextHost_TxImmReleaseContext	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxImmReleaseContext(This,a)

Definition at line 370 of file editor.h.

◆ ITextHost_TxInvalidateRect

#define ITextHost_TxInvalidateRect	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxInvalidateRect(This,a,b)

Definition at line 339 of file editor.h.

◆ ITextHost_TxKillTimer

#define ITextHost_TxKillTimer	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxKillTimer(This,a)

Definition at line 345 of file editor.h.

◆ ITextHost_TxNotify

#define ITextHost_TxNotify	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxNotify(This,a,b)

Definition at line 368 of file editor.h.

◆ ITextHost_TxReleaseDC

#define ITextHost_TxReleaseDC	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxReleaseDC(This,a)

Definition at line 334 of file editor.h.

◆ ITextHost_TxScreenToClient

#define ITextHost_TxScreenToClient	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxScreenToClient(This,a)

Definition at line 350 of file editor.h.

◆ ITextHost_TxScrollWindowEx

#define ITextHost_TxScrollWindowEx	(	This,
		a,
		b,
		c,
		d,
		e,
		f,
		g
	)	TXTHOST_VTABLE(This)->TxScrollWindowEx(This,a,b,c,d,e,f,g)

Definition at line 346 of file editor.h.

◆ ITextHost_TxSetCapture

#define ITextHost_TxSetCapture	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxSetCapture(This,a)

Definition at line 347 of file editor.h.

◆ ITextHost_TxSetCaretPos

#define ITextHost_TxSetCaretPos	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxSetCaretPos(This,a,b)

Definition at line 343 of file editor.h.

◆ ITextHost_TxSetCursor

#define ITextHost_TxSetCursor	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxSetCursor(This,a,b)

Definition at line 349 of file editor.h.

◆ ITextHost_TxSetFocus

#define ITextHost_TxSetFocus ( This ) TXTHOST_VTABLE(This)->TxSetFocus(This)

Definition at line 348 of file editor.h.

◆ ITextHost_TxSetScrollPos

#define ITextHost_TxSetScrollPos	(	This,
		a,
		b,
		c
	)	TXTHOST_VTABLE(This)->TxSetScrollPos(This,a,b,c)

Definition at line 338 of file editor.h.

◆ ITextHost_TxSetScrollRange

#define ITextHost_TxSetScrollRange	(	This,
		a,
		b,
		c,
		d
	)	TXTHOST_VTABLE(This)->TxSetScrollRange(This,a,b,c,d)

Definition at line 337 of file editor.h.

◆ ITextHost_TxSetTimer

#define ITextHost_TxSetTimer	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxSetTimer(This,a,b)

Definition at line 344 of file editor.h.

◆ ITextHost_TxShowCaret

#define ITextHost_TxShowCaret	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxShowCaret(This,a)

Definition at line 342 of file editor.h.

◆ ITextHost_TxShowScrollBar

#define ITextHost_TxShowScrollBar	(	This,
		a,
		b
	)	TXTHOST_VTABLE(This)->TxShowScrollBar(This,a,b)

Definition at line 335 of file editor.h.

◆ ITextHost_TxViewChange

#define ITextHost_TxViewChange	(	This,
		a
	)	TXTHOST_VTABLE(This)->TxViewChange(This,a)

Definition at line 340 of file editor.h.

◆ ITextServices_OnTxInPlaceActivate

#define ITextServices_OnTxInPlaceActivate	(	This,
		a
	)	TXTSERV_VTABLE(This)->OnTxInPlaceActivate(This,a)

Definition at line 414 of file editor.h.

◆ ITextServices_OnTxInPlaceDeactivate

#define ITextServices_OnTxInPlaceDeactivate ( This ) TXTSERV_VTABLE(This)->OnTxInPlaceDeactivate(This)

Definition at line 415 of file editor.h.

◆ ITextServices_OnTxPropertyBitsChange

#define ITextServices_OnTxPropertyBitsChange	(	This,
		a,
		b
	)	TXTSERV_VTABLE(This)->OnTxPropertyBitsChange(This,a,b)

Definition at line 424 of file editor.h.

◆ ITextServices_OnTxSetCursor

#define ITextServices_OnTxSetCursor	(	This,
		a,
		b,
		c,
		d,
		e,
		f,
		g,
		h,
		i
	)	TXTSERV_VTABLE(This)->OnTxSetCursor(This,a,b,c,d,e,f,g,h,i)

Definition at line 412 of file editor.h.

◆ ITextServices_OnTxUIActivate

#define ITextServices_OnTxUIActivate ( This ) TXTSERV_VTABLE(This)->OnTxUIActivate(This)

Definition at line 416 of file editor.h.

◆ ITextServices_OnTxUIDeactivate

#define ITextServices_OnTxUIDeactivate ( This ) TXTSERV_VTABLE(This)->OnTxUIDeactivate(This)

Definition at line 417 of file editor.h.

◆ ITextServices_TxDraw

#define ITextServices_TxDraw	(	This,
		a,
		b,
		c,
		d,
		e,
		f,
		g,
		h,
		i,
		j,
		k,
		l
	)	TXTSERV_VTABLE(This)->TxDraw(This,a,b,c,d,e,f,g,h,i,j,k,l)

Definition at line 409 of file editor.h.

◆ ITextServices_TxGetBaseLinePos

#define ITextServices_TxGetBaseLinePos	(	This,
		a
	)	TXTSERV_VTABLE(This)->TxGetBaseLinePos(This,a)

Definition at line 421 of file editor.h.

◆ ITextServices_TxGetCachedSize

#define ITextServices_TxGetCachedSize	(	This,
		a,
		b
	)	TXTSERV_VTABLE(This)->TxGetCachedSize(This,a,b)

Definition at line 425 of file editor.h.

◆ ITextServices_TxGetCurTargetX

#define ITextServices_TxGetCurTargetX	(	This,
		a
	)	TXTSERV_VTABLE(This)->TxGetCurTargetX(This,a)

Definition at line 420 of file editor.h.

◆ ITextServices_TxGetDropTarget

#define ITextServices_TxGetDropTarget	(	This,
		a
	)	TXTSERV_VTABLE(This)->TxGetDropTarget(This,a)

Definition at line 423 of file editor.h.

◆ ITextServices_TxGetHScroll

#define ITextServices_TxGetHScroll	(	This,
		a,
		b,
		c,
		d,
		e
	)	TXTSERV_VTABLE(This)->TxGetHScroll(This,a,b,c,d,e)

Definition at line 410 of file editor.h.

◆ ITextServices_TxGetNaturalSize

#define ITextServices_TxGetNaturalSize	(	This,
		a,
		b,
		c,
		d,
		e,
		f,
		g,
		h
	)	TXTSERV_VTABLE(This)->TxGetNaturalSize(This,a,b,c,d,e,f,g,h)

Definition at line 422 of file editor.h.

◆ ITextServices_TxGetText

#define ITextServices_TxGetText	(	This,
		a
	)	TXTSERV_VTABLE(This)->TxGetText(This,a)

Definition at line 418 of file editor.h.

◆ ITextServices_TxGetVScroll

#define ITextServices_TxGetVScroll	(	This,
		a,
		b,
		c,
		d,
		e
	)	TXTSERV_VTABLE(This)->TxGetVScroll(This,a,b,c,d,e)

Definition at line 411 of file editor.h.

◆ ITextServices_TxQueryHitPoint

#define ITextServices_TxQueryHitPoint	(	This,
		a,
		b,
		c,
		d,
		e,
		f,
		g,
		h,
		i,
		j
	)	TXTSERV_VTABLE(This)->TxQueryHitPoint(This,a,b,c,d,e,f,g,h,i,j)

Definition at line 413 of file editor.h.

◆ ITextServices_TxSendMessage

#define ITextServices_TxSendMessage	(	This,
		a,
		b,
		c,
		d
	)	TXTSERV_VTABLE(This)->TxSendMessage(This,a,b,c,d)

Definition at line 408 of file editor.h.

◆ ITextServices_TxSetText

#define ITextServices_TxSetText	(	This,
		a
	)	TXTSERV_VTABLE(This)->TxSetText(This,a)

Definition at line 419 of file editor.h.

◆ RUN_IS_HIDDEN

#define RUN_IS_HIDDEN ( run )

Value:

((run)->style->fmt.dwMask & CFM_HIDDEN \

&& (run)->style->fmt.dwEffects & CFE_HIDDEN)

style

Arabic default style

Definition: afstyles.h:94

CFE_HIDDEN

#define CFE_HIDDEN

Definition: richedit.h:418

CFM_HIDDEN

#define CFM_HIDDEN

Definition: richedit.h:340

Definition at line 30 of file editor.h.

◆ TXTHOST_VTABLE

#define TXTHOST_VTABLE ( This ) (This)->lpVtbl

Definition at line 330 of file editor.h.

◆ TXTSERV_VTABLE

#define TXTSERV_VTABLE ( This ) (This)->lpVtbl

Definition at line 406 of file editor.h.

Function Documentation

◆ add_undo_delete_run()

BOOL add_undo_delete_run	(	ME_TextEditor *	editor,
		int	pos,
		int	len
	)

Definition at line 204 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_delete_run );
    if (!undo) return FALSE;
 
    undo->u.delete_run.pos = pos;
    undo->u.delete_run.len = len;
 
    return TRUE;
}

Referenced by run_insert().

◆ add_undo_insert_run()

BOOL add_undo_insert_run	(	ME_TextEditor *	editor,
		int	pos,
		const WCHAR *	str,
		int	len,
		int	flags,
		ME_Style *	style
	)

Definition at line 131 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_insert_run );
    if (!undo) return FALSE;
 
    undo->u.insert_run.str = heap_alloc( (len + 1) * sizeof(WCHAR) );
    if (!undo->u.insert_run.str)
    {
        ME_EmptyUndoStack( editor );
        return FALSE;
    }
    memcpy( undo->u.insert_run.str, str, len * sizeof(WCHAR) );
    undo->u.insert_run.str[len] = 0;
    undo->u.insert_run.pos = pos;
    undo->u.insert_run.len = len;
    undo->u.insert_run.flags = flags;
    undo->u.insert_run.style = style;
    ME_AddRefStyle( style );
    return TRUE;
}

Referenced by ME_InternalDeleteText().

◆ add_undo_join_paras()

BOOL add_undo_join_paras	(	ME_TextEditor *	editor,
		int	pos
	)

Definition at line 176 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_join_paras );
    if (!undo) return FALSE;
 
    undo->u.join_paras.pos = pos;
    return TRUE;
}

Referenced by para_split().

◆ add_undo_set_char_fmt()

BOOL add_undo_set_char_fmt	(	ME_TextEditor *	editor,
		int	pos,
		int	len,
		const CHARFORMAT2W *	fmt
	)

Definition at line 164 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_set_char_fmt );
    if (!undo) return FALSE;
 
    undo->u.set_char_fmt.pos = pos;
    undo->u.set_char_fmt.len = len;
    undo->u.set_char_fmt.fmt = *fmt;
 
    return TRUE;
}

Referenced by ME_SetCharFormat().

◆ add_undo_set_para_fmt()

BOOL add_undo_set_para_fmt	(	ME_TextEditor *	editor,
		const ME_Paragraph *	para
	)

Definition at line 152 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_set_para_fmt );
    if (!undo) return FALSE;
 
    undo->u.set_para_fmt.pos = para->nCharOfs;
    undo->u.set_para_fmt.fmt = para->fmt;
    undo->u.set_para_fmt.border = para->border;
 
    return TRUE;
}

Referenced by ME_PlayUndoItem(), para_join(), and para_set_fmt().

◆ add_undo_split_para()

BOOL add_undo_split_para	(	ME_TextEditor *	editor,
		const ME_Paragraph *	para,
		ME_String *	eol_str,
		const ME_Cell *	cell
	)

Definition at line 185 of file undo.c.

{
    struct undo_item *undo = add_undo( editor, undo_split_para );
    if (!undo) return FALSE;
 
    undo->u.split_para.pos = para->nCharOfs - eol_str->nLen;
    undo->u.split_para.eol_str = eol_str;
    undo->u.split_para.fmt = para->fmt;
    undo->u.split_para.border = para->border;
    undo->u.split_para.flags = para->prev_para->member.para.nFlags & ~MEPF_CELL;
 
    if (cell)
    {
        undo->u.split_para.cell_border = cell->border;
        undo->u.split_para.cell_right_boundary = cell->nRightBoundary;
    }
    return TRUE;
}

Referenced by para_join().

◆ cell_create()

ME_Cell * cell_create ( void )

Definition at line 186 of file table.c.

{
    ME_DisplayItem *item = ME_MakeDI( diCell );
    return &item->member.cell;
}

Referenced by para_split().

◆ cell_end_para()

ME_Paragraph * cell_end_para ( ME_Cell * cell )

Definition at line 207 of file table.c.

{
    ME_Cell *next = cell_next( cell );
 
    if (!next) return cell_first_para( cell ); /* End of row */
 
    return &ME_FindItemBack( cell_get_di( next ), diParagraph )->member.para;
}

Referenced by adjust_para_y(), cursor_move_line(), draw_table_borders(), editor_draw(), and table_select_next_cell_or_append().

◆ cell_first_para()

ME_Paragraph * cell_first_para ( ME_Cell * cell )

Definition at line 202 of file table.c.

{
    return &ME_FindItemFwd( cell_get_di( cell ), diParagraph )->member.para;
}

Referenced by cell_end_para(), cursor_move_line(), draw_table_borders(), editor_draw(), ME_RTFSpecialCharHook(), pixel_pos_in_table_row(), and table_select_next_cell_or_append().

◆ cell_get_di()

static ME_DisplayItem * cell_get_di ( ME_Cell * cell )

inlinestatic

Definition at line 319 of file editor.h.

{
    return (ME_DisplayItem *)((ptrdiff_t)cell - offsetof(ME_DisplayItem, member));
}

Referenced by cell_end_para(), cell_first_para(), para_join(), para_split(), table_outer_para(), table_row_end(), and table_row_start().

◆ cell_next()

ME_Cell * cell_next ( ME_Cell * cell )

Definition at line 192 of file table.c.

{
    return cell->next_cell;
}

Referenced by adjust_para_y(), cell_end_para(), cursor_move_line(), draw_table_borders(), ME_RTFSpecialCharHook(), para_join(), pixel_pos_in_table_row(), stream_out_table_props(), table_append_row(), table_row_end(), table_row_end_cell(), and table_select_next_cell_or_append().

◆ cell_prev()

ME_Cell * cell_prev ( ME_Cell * cell )

Definition at line 197 of file table.c.

{
    return cell->prev_cell;
}

Referenced by adjust_para_y(), cursor_move_line(), ME_BeginRow(), ME_RTFSpecialCharHook(), para_join(), para_split(), and table_row_start().

◆ cf2w_to_cfany()

BOOL cf2w_to_cfany	(	CHARFORMAT2W *	to,
		const CHARFORMAT2W *	from
	)

Definition at line 79 of file style.c.

{
  assert(from->cbSize == sizeof(CHARFORMAT2W));
  if (to->cbSize == sizeof(CHARFORMATA))
  {
    CHARFORMATA *t = (CHARFORMATA *)to;
    CopyMemory(t, from, FIELD_OFFSET(CHARFORMATA, szFaceName));
    WideCharToMultiByte(CP_ACP, 0, from->szFaceName, -1, t->szFaceName, sizeof(t->szFaceName), NULL, NULL);
    t->cbSize = sizeof(*t); /* it was overwritten by CopyMemory */
    t->dwMask &= CFM_ALL;
    t->dwEffects &= CFM_EFFECTS;
    return TRUE;
  }
  if (to->cbSize == sizeof(CHARFORMATW))
  {
    CHARFORMATW *t = (CHARFORMATW *)to;
    CopyMemory(t, from, sizeof(*t));
    t->cbSize = sizeof(*t); /* it was overwritten by CopyMemory */
    t->dwMask &= CFM_ALL;
    t->dwEffects &= CFM_EFFECTS;
    return TRUE;
  }
  if (to->cbSize == sizeof(CHARFORMAT2A))
  {
    CHARFORMAT2A *t = (CHARFORMAT2A *)to;
    /* copy the A structure without face name */
    CopyMemory(t, from, FIELD_OFFSET(CHARFORMATA, szFaceName));
    /* convert face name */
    WideCharToMultiByte(CP_ACP, 0, from->szFaceName, -1, t->szFaceName, sizeof(t->szFaceName), NULL, NULL);
    /* copy the rest of the 2A structure to 2W */
    CopyMemory(&t->wWeight, &from->wWeight, sizeof(CHARFORMAT2W)-FIELD_OFFSET(CHARFORMAT2W,wWeight));
    t->cbSize = sizeof(*t); /* it was overwritten by CopyMemory */
    return TRUE;
  }
  if (to->cbSize == sizeof(CHARFORMAT2W))
  {
    CopyMemory(to, from, sizeof(CHARFORMAT2W));
    return TRUE;
  }
  return FALSE;
}

Referenced by editor_handle_message().

◆ cfany_to_cf2w()

BOOL cfany_to_cf2w	(	CHARFORMAT2W *	to,
		const CHARFORMAT2W *	from
	)

Definition at line 36 of file style.c.

{
  if (from->cbSize == sizeof(CHARFORMATA))
  {
    CHARFORMATA *f = (CHARFORMATA *)from;
    CopyMemory(to, f, FIELD_OFFSET(CHARFORMATA, szFaceName));
    to->cbSize = sizeof(CHARFORMAT2W);
    if (f->dwMask & CFM_FACE) {
      MultiByteToWideChar(CP_ACP, 0, f->szFaceName, -1, to->szFaceName, ARRAY_SIZE(to->szFaceName));
    }
    return TRUE;
  }
  if (from->cbSize == sizeof(CHARFORMATW))
  {
    CHARFORMATW *f = (CHARFORMATW *)from;
    CopyMemory(to, f, sizeof(*f));
    /* theoretically, we don't need to zero the remaining memory */
    ZeroMemory(&to->wWeight, sizeof(CHARFORMAT2W)-FIELD_OFFSET(CHARFORMAT2W, wWeight));
    to->cbSize = sizeof(CHARFORMAT2W);
    return TRUE;
  }
  if (from->cbSize == sizeof(CHARFORMAT2A))
  {
    CHARFORMAT2A *f = (CHARFORMAT2A *)from;
    /* copy the A structure without face name */
    CopyMemory(to, f, FIELD_OFFSET(CHARFORMATA, szFaceName));
    /* convert face name */
    if (f->dwMask & CFM_FACE)
      MultiByteToWideChar(CP_ACP, 0, f->szFaceName, -1, to->szFaceName, ARRAY_SIZE(to->szFaceName));
    /* copy the rest of the 2A structure to 2W */
    CopyMemory(&to->wWeight, &f->wWeight, sizeof(CHARFORMAT2A)-FIELD_OFFSET(CHARFORMAT2A, wWeight));
    to->cbSize = sizeof(CHARFORMAT2W);
    return TRUE;
  }
  if (from->cbSize == sizeof(CHARFORMAT2W))
  {
    CopyMemory(to, from, sizeof(CHARFORMAT2W));
    return TRUE;
  }
 
  return FALSE;
}

Referenced by handle_EM_SETCHARFORMAT(), and ME_MakeFirstParagraph().

◆ create_caret()

void create_caret ( ME_TextEditor * ed )

Definition at line 251 of file caret.c.

{
  int x, y, height;
 
  cursor_coords( editor, &editor->pCursors[0], &x, &y, &height );
  ITextHost_TxCreateCaret(editor->texthost, NULL, 0, height);
  editor->caret_height = height;
  editor->caret_hidden = TRUE;
}

Referenced by editor_handle_message(), and update_caret().

◆ create_text_services()

HRESULT create_text_services	(	IUnknown *	outer,
		ITextHost *	text_host,
		IUnknown **	unk,
		BOOL	emulate_10
	)

Definition at line 577 of file txtsrv.c.

{
    struct text_services *services;
 
    TRACE( "%p %p --> %p\n", outer, text_host, unk );
    if (text_host == NULL) return E_POINTER;
 
    services = CoTaskMemAlloc( sizeof(*services) );
    if (services == NULL) return E_OUTOFMEMORY;
    services->ref = 1;
    services->IUnknown_inner.lpVtbl = &textservices_inner_vtbl;
    services->ITextServices_iface.lpVtbl = &textservices_vtbl;
    services->IRichEditOle_iface.lpVtbl = &re_ole_vtbl;
    services->ITextDocument2Old_iface.lpVtbl = &text_doc2old_vtbl;
    services->editor = ME_MakeEditor( text_host, emulate_10 );
    services->editor->richole = &services->IRichEditOle_iface;
 
    if (outer) services->outer_unk = outer;
    else services->outer_unk = &services->IUnknown_inner;
 
    services->text_selection = NULL;
    list_init( &services->rangelist );
    list_init( &services->clientsites );
 
    *unk = &services->IUnknown_inner;
    return S_OK;
}

Referenced by create_windowed_editor(), and CreateTextServices().

◆ cursor_coords()

void cursor_coords	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor,
		int *	x,
		int *	y,
		int *	height
	)

Definition at line 221 of file caret.c.

{
  ME_Row *row;
  ME_Run *run = cursor->run;
  ME_Paragraph *para = cursor->para;
  ME_Run *size_run = run, *prev;
  ME_Context c;
  int run_x;
  HDC hdc = ITextHost_TxGetDC( editor->texthost );
 
  assert(~para->nFlags & MEPF_REWRAP);
 
  row = row_from_cursor( cursor );
 
  ME_InitContext( &c, editor, hdc );
 
  if (!cursor->nOffset && (prev = run_prev( run ))) size_run = prev;
 
  run_x = ME_PointFromCharContext( &c, run, cursor->nOffset, TRUE );
 
  *height = size_run->nAscent + size_run->nDescent;
  *x = c.rcView.left + run->pt.x + run_x - editor->horz_si.nPos;
  *y = c.rcView.top + para->pt.y + row->nBaseline
       + run->pt.y - size_run->nAscent - editor->vert_si.nPos;
  ME_DestroyContext(&c);
  ITextHost_TxReleaseDC( editor->texthost, hdc );
  return;
}

Referenced by create_caret(), ITextRange_fnScrollIntoView(), and update_caret().

◆ cursor_from_char_ofs()

void cursor_from_char_ofs	(	ME_TextEditor *	editor,
		int	char_ofs,
		ME_Cursor *	cursor
	)

Definition at line 240 of file run.c.

{
    ME_Paragraph *para;
    ME_Run *run;
 
    char_ofs = min( max( char_ofs, 0 ), ME_GetTextLength( editor ) );
 
    /* Find the paragraph at the offset. */
    for (para = editor_first_para( editor );
         para_next( para )->nCharOfs <= char_ofs;
         para = para_next( para ))
        ;
 
    char_ofs -= para->nCharOfs;
 
    /* Find the run at the offset. */
    for (run = para_first_run( para );
         run_next( run ) && run_next( run )->nCharOfs <= char_ofs;
         run = run_next( run ))
        ;
 
    char_ofs -= run->nCharOfs;
 
    cursor->para = para;
    cursor->run = run;
    cursor->nOffset = char_ofs;
}

Referenced by editor_handle_message(), fnTextSrv_TxGetText(), get_textfont_prop_for_pos(), IRichEditOle_fnGetClipboardData(), IRichEditOle_fnGetObject(), ITextRange_fnGetChar(), ITextRange_fnGetText(), ITextRange_fnScrollIntoView(), ITextRange_fnSetText(), ME_FindText(), ME_GetSelectionType(), ME_InternalDeleteText(), ME_PlayUndoItem(), ME_StreamIn(), set_selection_cursors(), set_textfont_prop(), textrange_copy_or_cut(), textrange_endof(), textrange_move(), textrange_moveend(), textrange_movestart(), and textrange_set_font().

◆ cursor_next_run()

BOOL cursor_next_run	(	ME_Cursor *	cursor,
		BOOL	all_para
	)

Definition at line 30 of file run.c.

{
    ME_DisplayItem *p = run_get_di( cursor->run )->next;
 
    while (p->type != diTextEnd)
    {
        if (p->type == diParagraph && !all_para) return FALSE;
        else if (p->type == diRun)
        {
            cursor->run = &p->member.run;
            cursor->para = cursor->run->para;
            cursor->nOffset = 0;
            return TRUE;
        }
        p = p->next;
    }
    return FALSE;
}

Referenced by ME_FindNextURLCandidate(), ME_StreamOutRTF(), run_next(), and run_next_all_paras().

◆ cursor_prev_run()

BOOL cursor_prev_run	(	ME_Cursor *	cursor,
		BOOL	all_para
	)

Definition at line 49 of file run.c.

{
    ME_DisplayItem *p = run_get_di( cursor->run )->prev;
 
    while (p->type != diTextStart)
    {
        if (p->type == diParagraph && !all_para) return FALSE;
        else if (p->type == diRun)
        {
            cursor->run = &p->member.run;
            cursor->para = cursor->run->para;
            cursor->nOffset = 0;
            return TRUE;
        }
        p = p->prev;
    }
    return FALSE;
}

Referenced by run_prev(), and run_prev_all_paras().

◆ debugstr_run()

static const char * debugstr_run ( const ME_Run * run )

inlinestatic

Definition at line 47 of file editor.h.

{
    return debugstr_wn( get_text( run, 0 ), run->len );
}

Referenced by itemize_para(), ME_CheckCharOffsets(), ME_DumpDocument(), ME_InternalDeleteText(), ME_MaximizeSplit(), ME_SplitByBacktracking(), and split_run_extents().

◆ draw_ole()

void draw_ole	(	ME_Context *	c,
		int	x,
		int	y,
		ME_Run *	run,
		BOOL	selected
	)

Definition at line 5726 of file richole.c.

{
  IDataObject*  ido;
  FORMATETC     fmt;
  STGMEDIUM     stgm;
  DIBSECTION    dibsect;
  ENHMETAHEADER emh;
  HDC           hMemDC;
  SIZE          sz;
  BOOL          has_size;
  HBITMAP       old_bm;
  RECT          rc;
 
  assert(run->nFlags & MERF_GRAPHICS);
  assert(run->reobj);
  if (IOleObject_QueryInterface(run->reobj->obj.poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
  {
    FIXME("Couldn't get interface\n");
    return;
  }
  has_size = run->reobj->obj.sizel.cx != 0 || run->reobj->obj.sizel.cy != 0;
  fmt.cfFormat = CF_BITMAP;
  fmt.ptd = NULL;
  fmt.dwAspect = DVASPECT_CONTENT;
  fmt.lindex = -1;
  fmt.tymed = TYMED_GDI;
  if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
  {
    fmt.cfFormat = CF_ENHMETAFILE;
    fmt.tymed = TYMED_ENHMF;
    if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
    {
      FIXME("Couldn't get storage medium\n");
      IDataObject_Release(ido);
      return;
    }
  }
  IDataObject_Release(ido);
 
  switch (stgm.tymed)
  {
  case TYMED_GDI:
    GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
    hMemDC = CreateCompatibleDC(c->hDC);
    old_bm = SelectObject(hMemDC, stgm.u.hBitmap);
    if (has_size)
    {
      convert_sizel(c, &run->reobj->obj.sizel, &sz);
    } else {
      sz.cx = dibsect.dsBm.bmWidth;
      sz.cy = dibsect.dsBm.bmHeight;
    }
    if (c->editor->nZoomNumerator != 0)
    {
      sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
      sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
    }
    StretchBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy,
               hMemDC, 0, 0, dibsect.dsBm.bmWidth, dibsect.dsBm.bmHeight, SRCCOPY);
 
    SelectObject(hMemDC, old_bm);
    DeleteDC(hMemDC);
    break;
  case TYMED_ENHMF:
    GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
    if (has_size)
    {
      convert_sizel(c, &run->reobj->obj.sizel, &sz);
    } else {
      sz.cx = emh.rclBounds.right - emh.rclBounds.left;
      sz.cy = emh.rclBounds.bottom - emh.rclBounds.top;
    }
    if (c->editor->nZoomNumerator != 0)
    {
      sz.cx = MulDiv(sz.cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
      sz.cy = MulDiv(sz.cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
    }
 
    rc.left = x;
    rc.top = y - sz.cy;
    rc.right = x + sz.cx;
    rc.bottom = y;
    PlayEnhMetaFile(c->hDC, stgm.u.hEnhMetaFile, &rc);
    break;
  default:
    FIXME("Unsupported tymed %d\n", stgm.tymed);
    selected = FALSE;
    break;
  }
  ReleaseStgMedium(&stgm);
 
  if (selected && !c->editor->bHideSelection)
    PatBlt(c->hDC, x, y - sz.cy, sz.cx, sz.cy, DSTINVERT);
}

Referenced by draw_run().

◆ editor_copy_or_cut()

HRESULT editor_copy_or_cut	(	ME_TextEditor *	editor,
		BOOL	cut,
		ME_Cursor *	start,
		int	count,
		IDataObject **	data_out
	)

Definition at line 2355 of file editor.c.

{
    HRESULT hr;
 
    if (cut && (editor->props & TXTBIT_READONLY))
    {
        return E_ACCESSDENIED;
    }
 
    hr = editor_copy( editor, start, count, data_out );
    if (SUCCEEDED(hr) && cut)
    {
        ME_InternalDeleteText( editor, start, count, FALSE );
        ME_CommitUndo( editor );
        ME_UpdateRepaint( editor, TRUE );
    }
    return hr;
}

Referenced by copy_or_cut(), and textrange_copy_or_cut().

◆ editor_draw()

void editor_draw	(	ME_TextEditor *	editor,
		HDC	hDC,
		const RECT *	update
	)

Definition at line 33 of file paint.c.

{
  ME_Paragraph *para;
  ME_Context c;
  ME_Cell *cell;
  int ys, ye;
  HRGN oldRgn;
  RECT rc, client;
  HBRUSH brush = CreateSolidBrush( ITextHost_TxGetSysColor( editor->texthost, COLOR_WINDOW ) );
 
  ME_InitContext( &c, editor, hDC );
  if (!update)
  {
      client = c.rcView;
      client.left -= editor->selofs;
      update = &client;
  }
 
  oldRgn = CreateRectRgn(0, 0, 0, 0);
  if (!GetClipRgn(hDC, oldRgn))
  {
    DeleteObject(oldRgn);
    oldRgn = NULL;
  }
  IntersectClipRect( hDC, update->left, update->top, update->right, update->bottom );
 
  brush = SelectObject( hDC, brush );
  SetBkMode(hDC, TRANSPARENT);
 
  para = editor_first_para( editor );
  /* This context point is an offset for the paragraph positions stored
   * during wrapping. It shouldn't be modified during painting. */
  c.pt.x = c.rcView.left - editor->horz_si.nPos;
  c.pt.y = c.rcView.top - editor->vert_si.nPos;
  while (para_next( para ))
  {
    ys = c.pt.y + para->pt.y;
    cell = para_cell( para );
    if (cell && para == cell_end_para( cell ))
      ye = c.pt.y + cell->pt.y + cell->nHeight;
    else ye = ys + para->nHeight;
 
    if (cell && !(para->nFlags & MEPF_ROWEND) && para == cell_first_para( cell ))
    {
      /* the border shifts the text down */
      ys -= para_cell( para )->yTextOffset;
    }
 
    /* Draw the paragraph if any of the paragraph is in the update region. */
    if (ys < update->bottom && ye > update->top)
      draw_paragraph( &c, para );
    para = para_next( para );
  }
  if (editor_opaque( editor ))
  {
    if (c.pt.y + editor->nTotalLength < c.rcView.bottom)
    { /* space after the end of the text */
      rc.top = c.pt.y + editor->nTotalLength;
      rc.left = c.rcView.left;
      rc.bottom = c.rcView.bottom;
      rc.right = c.rcView.right;
      if (IntersectRect( &rc, &rc, update ))
        PatBlt(hDC, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY);
    }
    if (editor->selofs)
    { /* selection bar */
      rc.left = c.rcView.left - editor->selofs;
      rc.top = c.rcView.top;
      rc.right = c.rcView.left;
      rc.bottom = c.rcView.bottom;
      if (IntersectRect( &rc, &rc, update ))
        PatBlt( hDC, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY );
    }
  }
 
  DeleteObject( SelectObject( hDC, brush ) );
  SelectClipRgn( hDC, oldRgn );
  if (oldRgn) DeleteObject( oldRgn );
  ME_DestroyContext( &c );
 
  if (editor->nTotalLength != editor->nLastTotalLength || editor->nTotalWidth != editor->nLastTotalWidth)
    ME_SendRequestResize(editor, FALSE);
  editor->nLastTotalLength = editor->nTotalLength;
  editor->nLastTotalWidth = editor->nTotalWidth;
}

Referenced by fnTextSrv_TxDraw().

◆ editor_end_para()

ME_Paragraph * editor_end_para ( ME_TextEditor * editor )

Definition at line 285 of file editor.c.

{
    return &editor->pBuffer->pLast->member.para;
}

Referenced by editor_handle_message(), editor_mark_rewrap_all(), ME_ArrowPageDown(), ME_GetTextW(), ME_InvalidateSelection(), and ME_SetCursorToEnd().

◆ editor_ensure_visible()

void editor_ensure_visible	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor
	)

Definition at line 1206 of file paint.c.

{
  ME_Run *run = cursor->run;
  ME_Row *row = row_from_cursor( cursor );
  ME_Paragraph *para = cursor->para;
  int x, y, yheight;
 
 
  if (editor->scrollbars & ES_AUTOHSCROLL)
  {
    x = run->pt.x + ME_PointFromChar( editor, run, cursor->nOffset, TRUE );
    if (x > editor->horz_si.nPos + editor->sizeWindow.cx)
      x = x + 1 - editor->sizeWindow.cx;
    else if (x > editor->horz_si.nPos)
      x = editor->horz_si.nPos;
 
    if (~editor->scrollbars & ES_AUTOVSCROLL)
    {
      scroll_h_abs( editor, x, TRUE );
      return;
    }
  }
  else
  {
    if (~editor->scrollbars & ES_AUTOVSCROLL) return;
    x = editor->horz_si.nPos;
  }
 
  y = para->pt.y + row->pt.y;
  yheight = row->nHeight;
 
  if (y < editor->vert_si.nPos)
    scroll_abs( editor, x, y, TRUE );
  else if (y + yheight > editor->vert_si.nPos + editor->sizeWindow.cy)
    scroll_abs( editor, x, y + yheight - editor->sizeWindow.cy, TRUE );
  else if (x != editor->horz_si.nPos)
    scroll_abs( editor, x, editor->vert_si.nPos, TRUE );
}

Referenced by editor_handle_message(), ME_ArrowKey(), ME_MouseMove(), and ME_UpdateRepaint().

◆ editor_first_para()

ME_Paragraph * editor_first_para ( ME_TextEditor * editor )

Definition at line 279 of file editor.c.

{
    return para_next( &editor->pBuffer->pFirst->member.para );
}

Referenced by cursor_from_char_ofs(), cursor_from_virtual_coords(), editor_draw(), editor_handle_message(), editor_mark_rewrap_all(), handle_enter(), ME_ArrowPageUp(), ME_InvalidateSelection(), ME_SetCursorToStart(), row_from_row_number(), and row_number_from_char_ofs().

◆ editor_get_selection_para_fmt()

void editor_get_selection_para_fmt	(	ME_TextEditor *	editor,
		PARAFORMAT2 *	fmt
	)

Definition at line 905 of file para.c.

{
  ME_Paragraph *para, *para_end;
 
  if (fmt->cbSize < sizeof(PARAFORMAT))
  {
    fmt->dwMask = 0;
    return;
  }
 
  editor_get_selection_paras( editor, &para, &para_end );
 
  para_copy_fmt( para, fmt );
 
  /* Invalidate values that change across the selected paragraphs. */
  while (para != para_end)
  {
    para = para_next( para );
 
#define CHECK_FIELD(m, f) \
    if (fmt->f != para->fmt.f) fmt->dwMask &= ~(m);
 
    CHECK_FIELD(PFM_NUMBERING, wNumbering);
    CHECK_FIELD(PFM_STARTINDENT, dxStartIndent);
    CHECK_FIELD(PFM_RIGHTINDENT, dxRightIndent);
    CHECK_FIELD(PFM_OFFSET, dxOffset);
    CHECK_FIELD(PFM_ALIGNMENT, wAlignment);
    if (fmt->dwMask & PFM_TABSTOPS)
    {
      if (fmt->cTabCount != para->fmt.cTabCount ||
          memcmp(fmt->rgxTabs, para->fmt.rgxTabs, para->fmt.cTabCount * sizeof(int) ))
        fmt->dwMask &= ~PFM_TABSTOPS;
    }
 
    if (fmt->cbSize >= sizeof(PARAFORMAT2))
    {
      fmt->dwMask &= ~((fmt->wEffects ^ para->fmt.wEffects) << 16);
      CHECK_FIELD(PFM_SPACEBEFORE, dySpaceBefore);
      CHECK_FIELD(PFM_SPACEAFTER, dySpaceAfter);
      CHECK_FIELD(PFM_LINESPACING, dyLineSpacing);
      CHECK_FIELD(PFM_STYLE, sStyle);
      CHECK_FIELD(PFM_SPACEAFTER, bLineSpacingRule);
      CHECK_FIELD(PFM_SHADING, wShadingWeight);
      CHECK_FIELD(PFM_SHADING, wShadingStyle);
      CHECK_FIELD(PFM_NUMBERINGSTART, wNumberingStart);
      CHECK_FIELD(PFM_NUMBERINGSTYLE, wNumberingStyle);
      CHECK_FIELD(PFM_NUMBERINGTAB, wNumberingTab);
      CHECK_FIELD(PFM_BORDER, wBorderSpace);
      CHECK_FIELD(PFM_BORDER, wBorderWidth);
      CHECK_FIELD(PFM_BORDER, wBorders);
    }
#undef CHECK_FIELD
  }
}

Referenced by editor_handle_message(), and ME_RTFParAttrHook().

◆ editor_get_selection_paras()

void editor_get_selection_paras	(	ME_TextEditor *	editor,
		ME_Paragraph **	para,
		ME_Paragraph **	para_end
	)

Definition at line 850 of file para.c.

{
  ME_Cursor *pEndCursor = &editor->pCursors[1];
 
  *para = editor->pCursors[0].para;
  *para_end = editor->pCursors[1].para;
  if (*para == *para_end)
    return;
 
  if ((*para_end)->nCharOfs < (*para)->nCharOfs)
  {
    ME_Paragraph *tmp = *para;
 
    *para = *para_end;
    *para_end = tmp;
    pEndCursor = &editor->pCursors[0];
  }
 
  /* The paragraph at the end of a non-empty selection isn't included
   * if the selection ends at the start of the paragraph. */
  if (!pEndCursor->run->nCharOfs && !pEndCursor->nOffset)
    *para_end = para_prev( *para_end );
}

Referenced by editor_get_selection_para_fmt(), editor_set_selection_para_fmt(), and ME_InvalidateSelection().

◆ editor_handle_message()

LRESULT editor_handle_message	(	ME_TextEditor *	editor,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam,
		HRESULT *	phresult
	)

Definition at line 3256 of file editor.c.

{
  *phresult = S_OK;
 
  switch(msg) {
 
  UNSUPPORTED_MSG(EM_DISPLAYBAND)
  UNSUPPORTED_MSG(EM_FINDWORDBREAK)
  UNSUPPORTED_MSG(EM_FMTLINES)
  UNSUPPORTED_MSG(EM_FORMATRANGE)
  UNSUPPORTED_MSG(EM_GETBIDIOPTIONS)
  UNSUPPORTED_MSG(EM_GETEDITSTYLE)
  UNSUPPORTED_MSG(EM_GETIMECOMPMODE)
  UNSUPPORTED_MSG(EM_GETIMESTATUS)
  UNSUPPORTED_MSG(EM_SETIMESTATUS)
  UNSUPPORTED_MSG(EM_GETLANGOPTIONS)
  UNSUPPORTED_MSG(EM_GETREDONAME)
  UNSUPPORTED_MSG(EM_GETTYPOGRAPHYOPTIONS)
  UNSUPPORTED_MSG(EM_GETUNDONAME)
  UNSUPPORTED_MSG(EM_GETWORDBREAKPROCEX)
  UNSUPPORTED_MSG(EM_SETBIDIOPTIONS)
  UNSUPPORTED_MSG(EM_SETEDITSTYLE)
  UNSUPPORTED_MSG(EM_SETLANGOPTIONS)
  UNSUPPORTED_MSG(EM_SETMARGINS)
  UNSUPPORTED_MSG(EM_SETPALETTE)
  UNSUPPORTED_MSG(EM_SETTABSTOPS)
  UNSUPPORTED_MSG(EM_SETTYPOGRAPHYOPTIONS)
  UNSUPPORTED_MSG(EM_SETWORDBREAKPROCEX)
 
/* Messages specific to Richedit controls */
 
  case EM_STREAMIN:
   return ME_StreamIn(editor, wParam, (EDITSTREAM*)lParam, TRUE);
  case EM_STREAMOUT:
   return ME_StreamOut(editor, wParam, (EDITSTREAM *)lParam);
  case EM_EMPTYUNDOBUFFER:
    ME_EmptyUndoStack(editor);
    return 0;
  case EM_GETSEL:
  {
    /* Note: wParam/lParam can be NULL */
    UINT from, to;
    PUINT pfrom = wParam ? (PUINT)wParam : &from;
    PUINT pto = lParam ? (PUINT)lParam : &to;
    ME_GetSelectionOfs(editor, (int *)pfrom, (int *)pto);
    if ((*pfrom|*pto) & 0xFFFF0000)
      return -1;
    return MAKELONG(*pfrom,*pto);
  }
  case EM_EXGETSEL:
  {
    CHARRANGE *pRange = (CHARRANGE *)lParam;
    ME_GetSelectionOfs(editor, &pRange->cpMin, &pRange->cpMax);
    TRACE("EM_EXGETSEL = (%d,%d)\n", pRange->cpMin, pRange->cpMax);
    return 0;
  }
  case EM_SETUNDOLIMIT:
  {
    if ((int)wParam < 0)
      editor->nUndoLimit = STACK_SIZE_DEFAULT;
    else
      editor->nUndoLimit = min(wParam, STACK_SIZE_MAX);
    /* Setting a max stack size keeps wine from getting killed 
      for hogging memory. Windows allocates all this memory at once, so
      no program would realistically set a value above our maximum. */
    return editor->nUndoLimit;
  }
  case EM_CANUNDO:
    return !list_empty( &editor->undo_stack );
  case EM_CANREDO:
    return !list_empty( &editor->redo_stack );
  case WM_UNDO: /* FIXME: actually not the same */
  case EM_UNDO:
    return ME_Undo(editor);
  case EM_REDO:
    return ME_Redo(editor);
  case EM_SETFONTSIZE:
  {
      CHARFORMAT2W cf;
      LONG tmp_size, size;
      BOOL is_increase = ((LONG)wParam > 0);
 
      if (editor->mode & TM_PLAINTEXT)
          return FALSE;
 
      cf.cbSize = sizeof(cf);
      cf.dwMask = CFM_SIZE;
      ME_GetSelectionCharFormat(editor, &cf);
      tmp_size = (cf.yHeight / 20) + wParam;
 
      if (tmp_size <= 1)
          size = 1;
      else if (tmp_size > 12 && tmp_size < 28 && tmp_size % 2)
          size = tmp_size + (is_increase ? 1 : -1);
      else if (tmp_size > 28 && tmp_size < 36)
          size = is_increase ? 36 : 28;
      else if (tmp_size > 36 && tmp_size < 48)
          size = is_increase ? 48 : 36;
      else if (tmp_size > 48 && tmp_size < 72)
          size = is_increase ? 72 : 48;
      else if (tmp_size > 72 && tmp_size < 80)
          size = is_increase ? 80 : 72;
      else if (tmp_size > 80 && tmp_size < 1638)
          size = 10 * (is_increase ? (tmp_size / 10 + 1) : (tmp_size / 10));
      else if (tmp_size >= 1638)
          size = 1638;
      else
          size = tmp_size;
 
      cf.yHeight = size * 20; /*  convert twips to points */
      ME_SetSelectionCharFormat(editor, &cf);
      ME_CommitUndo(editor);
      ME_WrapMarkedParagraphs(editor);
      ME_UpdateScrollBar(editor);
 
      return TRUE;
  }
  case EM_SETSEL:
  {
    return set_selection( editor, wParam, lParam );
  }
  case EM_SETSCROLLPOS:
  {
    POINT *point = (POINT *)lParam;
    scroll_abs( editor, point->x, point->y, TRUE );
    return 0;
  }
  case EM_AUTOURLDETECT:
  {
    if (wParam==1 || wParam ==0)
    {
        editor->AutoURLDetect_bEnable = (BOOL)wParam;
        return 0;
    }
    return E_INVALIDARG;
  }
  case EM_GETAUTOURLDETECT:
  {
    return editor->AutoURLDetect_bEnable;
  }
  case EM_EXSETSEL:
  {
    CHARRANGE range = *(CHARRANGE *)lParam;
 
    return set_selection( editor, range.cpMin, range.cpMax );
  }
  case EM_SETTEXTEX:
  {
    LPWSTR wszText;
    SETTEXTEX *pStruct = (SETTEXTEX *)wParam;
    int from, to, len;
    ME_Style *style;
    BOOL bRtf, bUnicode, bSelection, bUTF8;
    int oldModify = editor->nModifyStep;
    static const char utf8_bom[] = {0xef, 0xbb, 0xbf};
 
    if (!pStruct) return 0;
 
    /* If we detect ascii rtf at the start of the string,
     * we know it isn't unicode. */
    bRtf = (lParam && (!strncmp((char *)lParam, "{\\rtf", 5) ||
                         !strncmp((char *)lParam, "{\\urtf", 6)));
    bUnicode = !bRtf && pStruct->codepage == CP_UNICODE;
    bUTF8 = (lParam && (!strncmp((char *)lParam, utf8_bom, 3)));
 
    TRACE("EM_SETTEXTEX - %s, flags %d, cp %d\n",
          bUnicode ? debugstr_w((LPCWSTR)lParam) : debugstr_a((LPCSTR)lParam),
          pStruct->flags, pStruct->codepage);
 
    bSelection = (pStruct->flags & ST_SELECTION) != 0;
    if (bSelection) {
      int nStartCursor = ME_GetSelectionOfs(editor, &from, &to);
      style = ME_GetSelectionInsertStyle(editor);
      ME_InternalDeleteText(editor, &editor->pCursors[nStartCursor], to - from, FALSE);
    } else {
      ME_Cursor start;
      ME_SetCursorToStart(editor, &start);
      ME_InternalDeleteText(editor, &start, ME_GetTextLength(editor), FALSE);
      style = editor->pBuffer->pDefaultStyle;
    }
 
    if (bRtf) {
      ME_StreamInRTFString(editor, bSelection, (char *)lParam);
      if (bSelection) {
        /* FIXME: The length returned doesn't include the rtf control
         * characters, only the actual text. */
        len = lParam ? strlen((char *)lParam) : 0;
      }
    } else {
      if (bUTF8 && !bUnicode) {
        wszText = ME_ToUnicode(CP_UTF8, (void *)(lParam+3), &len);
        ME_InsertTextFromCursor(editor, 0, wszText, len, style);
        ME_EndToUnicode(CP_UTF8, wszText);
      } else {
        wszText = ME_ToUnicode(pStruct->codepage, (void *)lParam, &len);
        ME_InsertTextFromCursor(editor, 0, wszText, len, style);
        ME_EndToUnicode(pStruct->codepage, wszText);
      }
    }
 
    if (bSelection) {
      ME_ReleaseStyle(style);
      ME_UpdateSelectionLinkAttribute(editor);
    } else {
      ME_Cursor cursor;
      len = 1;
      ME_SetCursorToStart(editor, &cursor);
      ME_UpdateLinkAttribute(editor, &cursor, INT_MAX);
    }
    ME_CommitUndo(editor);
    if (!(pStruct->flags & ST_KEEPUNDO))
    {
      editor->nModifyStep = oldModify;
      ME_EmptyUndoStack(editor);
    }
    ME_UpdateRepaint(editor, FALSE);
    return len;
  }
  case EM_SELECTIONTYPE:
    return ME_GetSelectionType(editor);
  case EM_GETMODIFY:
    return editor->nModifyStep == 0 ? 0 : -1;
  case EM_SETMODIFY:
  {
    if (wParam)
      editor->nModifyStep = 1;
    else
      editor->nModifyStep = 0;
    
    return 0;
  }
  case EM_SETEVENTMASK:
  {
    DWORD nOldMask = editor->nEventMask;
    
    editor->nEventMask = lParam;
    return nOldMask;
  }
  case EM_GETEVENTMASK:
    return editor->nEventMask;
  case EM_SETCHARFORMAT:
    return handle_EM_SETCHARFORMAT( editor, wParam, (CHARFORMAT2W *)lParam );
  case EM_GETCHARFORMAT:
  {
    CHARFORMAT2W tmp, *dst = (CHARFORMAT2W *)lParam;
    if (dst->cbSize != sizeof(CHARFORMATA) &&
        dst->cbSize != sizeof(CHARFORMATW) &&
        dst->cbSize != sizeof(CHARFORMAT2A) &&
        dst->cbSize != sizeof(CHARFORMAT2W))
      return 0;
    tmp.cbSize = sizeof(tmp);
    if (!wParam)
      ME_GetDefaultCharFormat(editor, &tmp);
    else
      ME_GetSelectionCharFormat(editor, &tmp);
    cf2w_to_cfany(dst, &tmp);
    return tmp.dwMask;
  }
  case EM_SETPARAFORMAT:
  {
    BOOL result = editor_set_selection_para_fmt( editor, (PARAFORMAT2 *)lParam );
    ME_WrapMarkedParagraphs(editor);
    ME_UpdateScrollBar(editor);
    ME_CommitUndo(editor);
    return result;
  }
  case EM_GETPARAFORMAT:
    editor_get_selection_para_fmt( editor, (PARAFORMAT2 *)lParam );
    return ((PARAFORMAT2 *)lParam)->dwMask;
  case EM_GETFIRSTVISIBLELINE:
  {
    ME_Paragraph *para = editor_first_para( editor );
    ME_Row *row;
    int y = editor->vert_si.nPos;
    int count = 0;
 
    while (para_next( para ))
    {
      if (y < para->pt.y + para->nHeight) break;
      count += para->nRows;
      para = para_next( para );
    }
 
    row = para_first_row( para );
    while (row)
    {
      if (y < para->pt.y + row->pt.y + row->nHeight) break;
      count++;
      row = row_next( row );
    }
    return count;
  }
  case EM_HIDESELECTION:
  {
     editor->bHideSelection = (wParam != 0);
     ME_InvalidateSelection(editor);
     return 0;
  }
  case EM_LINESCROLL:
  {
    if (!(editor->props & TXTBIT_MULTILINE))
      return FALSE;
    ME_ScrollDown( editor, lParam * get_default_line_height( editor ) );
    return TRUE;
  }
  case WM_CLEAR:
  {
    int from, to;
    int nStartCursor = ME_GetSelectionOfs(editor, &from, &to);
    ME_InternalDeleteText(editor, &editor->pCursors[nStartCursor], to-from, FALSE);
    ME_CommitUndo(editor);
    ME_UpdateRepaint(editor, TRUE);
    return 0;
  }
  case EM_REPLACESEL:
  {
    WCHAR *text = (WCHAR *)lParam;
    int len = text ? lstrlenW( text ) : 0;
 
    TRACE( "EM_REPLACESEL - %s\n", debugstr_w( text ) );
    ME_ReplaceSel( editor, !!wParam, text, len );
    return len;
  }
  case EM_SCROLLCARET:
    editor_ensure_visible( editor, &editor->pCursors[0] );
    return 0;
  case WM_SETFONT:
  {
    LOGFONTW lf;
    CHARFORMAT2W fmt;
    HDC hDC;
    BOOL bRepaint = LOWORD(lParam);
 
    if (!wParam)
      wParam = (WPARAM)GetStockObject(SYSTEM_FONT);
 
    if (!GetObjectW((HGDIOBJ)wParam, sizeof(LOGFONTW), &lf))
      return 0;
 
    hDC = ITextHost_TxGetDC(editor->texthost);
    ME_CharFormatFromLogFont(hDC, &lf, &fmt);
    ITextHost_TxReleaseDC(editor->texthost, hDC);
    if (editor->mode & TM_RICHTEXT) {
      ME_Cursor start;
      ME_SetCursorToStart(editor, &start);
      ME_SetCharFormat(editor, &start, NULL, &fmt);
    }
    ME_SetDefaultCharFormat(editor, &fmt);
 
    ME_CommitUndo(editor);
    editor_mark_rewrap_all( editor );
    ME_WrapMarkedParagraphs(editor);
    ME_UpdateScrollBar(editor);
    if (bRepaint)
      ME_Repaint(editor);
#ifdef __REACTOS__
    if (ImmIsIME(GetKeyboardLayout(0)))
    {
      HIMC hIMC = ImmGetContext(editor->hWnd);
      ImmSetCompositionFontW(hIMC, &lf);
      ImmReleaseContext(editor->hWnd, hIMC);
    }
#endif
    return 0;
  }
  case WM_SETTEXT:
  {
    ME_Cursor cursor;
    ME_SetCursorToStart(editor, &cursor);
    ME_InternalDeleteText(editor, &cursor, ME_GetTextLength(editor), FALSE);
    if (lParam)
    {
      TRACE("WM_SETTEXT lParam==%lx\n",lParam);
      if (!strncmp((char *)lParam, "{\\rtf", 5) ||
          !strncmp((char *)lParam, "{\\urtf", 6))
      {
        /* Undocumented: WM_SETTEXT supports RTF text */
        ME_StreamInRTFString(editor, 0, (char *)lParam);
      }
      else
        ME_SetText( editor, (void*)lParam, TRUE );
    }
    else
      TRACE("WM_SETTEXT - NULL\n");
    ME_SetCursorToStart(editor, &cursor);
    ME_UpdateLinkAttribute(editor, &cursor, INT_MAX);
    set_selection_cursors(editor, 0, 0);
    editor->nModifyStep = 0;
    ME_CommitUndo(editor);
    ME_EmptyUndoStack(editor);
    ME_UpdateRepaint(editor, FALSE);
    return 1;
  }
  case EM_CANPASTE:
    return paste_special( editor, 0, NULL, TRUE );
  case WM_PASTE:
  case WM_MBUTTONDOWN:
    wParam = 0;
    lParam = 0;
    /* fall through */
  case EM_PASTESPECIAL:
    paste_special( editor, wParam, (REPASTESPECIAL *)lParam, FALSE );
    return 0;
  case WM_CUT:
  case WM_COPY:
    copy_or_cut(editor, msg == WM_CUT);
    return 0;
  case WM_GETTEXTLENGTH:
  {
    GETTEXTLENGTHEX how;
    how.flags = GTL_CLOSE | (editor->bEmulateVersion10 ? 0 : GTL_USECRLF) | GTL_NUMCHARS;
    how.codepage = CP_UNICODE;
    return ME_GetTextLengthEx(editor, &how);
  }
  case EM_GETTEXTLENGTHEX:
    return ME_GetTextLengthEx(editor, (GETTEXTLENGTHEX *)wParam);
  case WM_GETTEXT:
  {
    GETTEXTEX ex;
    ex.cb = wParam * sizeof(WCHAR);
    ex.flags = GT_USECRLF;
    ex.codepage = CP_UNICODE;
    ex.lpDefaultChar = NULL;
    ex.lpUsedDefChar = NULL;
    return ME_GetTextEx(editor, &ex, lParam);
  }
  case EM_GETTEXTEX:
    return ME_GetTextEx(editor, (GETTEXTEX*)wParam, lParam);
  case EM_GETSELTEXT:
  {
    int nFrom, nTo, nStartCur = ME_GetSelectionOfs(editor, &nFrom, &nTo);
    ME_Cursor *from = &editor->pCursors[nStartCur];
    return get_text_range( editor, (WCHAR *)lParam, from, nTo - nFrom );
  }
  case EM_GETSCROLLPOS:
  {
    POINT *point = (POINT *)lParam;
    point->x = editor->horz_si.nPos;
    point->y = editor->vert_si.nPos;
    /* 16-bit scaled value is returned as stored in scrollinfo */
    if (editor->horz_si.nMax > 0xffff)
      point->x = MulDiv(point->x, 0xffff, editor->horz_si.nMax);
    if (editor->vert_si.nMax > 0xffff)
      point->y = MulDiv(point->y, 0xffff, editor->vert_si.nMax);
    return 1;
  }
  case EM_GETTEXTRANGE:
  {
    TEXTRANGEW *rng = (TEXTRANGEW *)lParam;
    ME_Cursor start;
    int nStart = rng->chrg.cpMin;
    int nEnd = rng->chrg.cpMax;
    int textlength = ME_GetTextLength(editor);
 
    TRACE( "EM_GETTEXTRANGE min = %d max = %d textlength = %d\n", rng->chrg.cpMin, rng->chrg.cpMax, textlength );
    if (nStart < 0) return 0;
    if ((nStart == 0 && nEnd == -1) || nEnd > textlength)
      nEnd = textlength;
    if (nStart >= nEnd) return 0;
 
    cursor_from_char_ofs( editor, nStart, &start );
    return get_text_range( editor, rng->lpstrText, &start, nEnd - nStart );
  }
  case EM_GETLINE:
  {
    ME_Row *row;
    ME_Run *run;
    const unsigned int nMaxChars = *(WORD *) lParam;
    unsigned int nCharsLeft = nMaxChars;
    char *dest = (char *) lParam;
    ME_Cursor start, end;
 
    TRACE( "EM_GETLINE: row=%d, nMaxChars=%d\n", (int)wParam, nMaxChars );
 
    row = row_from_row_number( editor, wParam );
    if (row == NULL) return 0;
 
    row_first_cursor( row, &start );
    row_end_cursor( row, &end, TRUE );
    run = start.run;
    while (nCharsLeft)
    {
      WCHAR *str;
      unsigned int nCopy;
      int ofs = (run == start.run) ? start.nOffset : 0;
      int len = (run == end.run) ? end.nOffset : run->len;
 
      str = get_text( run, ofs );
      nCopy = min( nCharsLeft, len );
 
      memcpy(dest, str, nCopy * sizeof(WCHAR));
      dest += nCopy * sizeof(WCHAR);
      nCharsLeft -= nCopy;
      if (run == end.run) break;
      run = row_next_run( row, run );
    }
 
    /* append line termination, space allowing */
    if (nCharsLeft > 0) *((WCHAR *)dest) = '\0';
 
    TRACE("EM_GETLINE: got %u characters\n", nMaxChars - nCharsLeft);
    return nMaxChars - nCharsLeft;
  }
  case EM_GETLINECOUNT:
  {
    int count = editor->total_rows;
    ME_Run *prev_run, *last_run;
 
    last_run = para_end_run( para_prev( editor_end_para( editor ) ) );
    prev_run = run_prev_all_paras( last_run );
 
    if (editor->bEmulateVersion10 && prev_run && last_run->nCharOfs == 0 &&
        prev_run->len == 1 && *get_text( prev_run, 0 ) == '\r')
    {
      /* In 1.0 emulation, the last solitary \r at the very end of the text
         (if one exists) is NOT a line break.
         FIXME: this is an ugly hack. This should have a more regular model. */
      count--;
    }
 
    count = max(1, count);
    TRACE("EM_GETLINECOUNT: count==%d\n", count);
    return count;
  }
  case EM_LINEFROMCHAR:
  {
    if (wParam == -1) wParam = ME_GetCursorOfs( editor->pCursors + 1 );
    return row_number_from_char_ofs( editor, wParam );
  }
  case EM_EXLINEFROMCHAR:
  {
    if (lParam == -1) lParam = ME_GetCursorOfs( editor->pCursors + 1 );
    return row_number_from_char_ofs( editor, lParam );
  }
  case EM_LINEINDEX:
  {
    ME_Row *row;
    ME_Cursor cursor;
    int ofs;
    
    if (wParam == -1) row = row_from_cursor( editor->pCursors );
    else row = row_from_row_number( editor, wParam );
    if (!row) return -1;
 
    row_first_cursor( row, &cursor );
    ofs = ME_GetCursorOfs( &cursor );
    TRACE( "EM_LINEINDEX: nCharOfs==%d\n", ofs );
    return ofs;
  }
  case EM_LINELENGTH:
  {
    ME_Row *row;
    int start_ofs, end_ofs;
    ME_Cursor cursor;
 
    if (wParam > ME_GetTextLength(editor))
      return 0;
    if (wParam == -1)
    {
      FIXME("EM_LINELENGTH: returning number of unselected characters on lines with selection unsupported.\n");
      return 0;
    }
    cursor_from_char_ofs( editor, wParam, &cursor );
    row = row_from_cursor( &cursor );
    row_first_cursor( row, &cursor );
    start_ofs = ME_GetCursorOfs( &cursor );
    row_end_cursor( row, &cursor, FALSE );
    end_ofs = ME_GetCursorOfs( &cursor );
    TRACE( "EM_LINELENGTH(%ld)==%d\n", wParam, end_ofs - start_ofs );
    return end_ofs - start_ofs;
  }
  case EM_EXLIMITTEXT:
  {
    if ((int)lParam < 0)
     return 0;
    if (lParam == 0)
      editor->nTextLimit = 65536;
    else
      editor->nTextLimit = (int) lParam;
    return 0;
  }
  case EM_LIMITTEXT:
  {
    if (wParam == 0)
      editor->nTextLimit = 65536;
    else
      editor->nTextLimit = (int) wParam;
    return 0;
  }
  case EM_GETLIMITTEXT:
  {
    return editor->nTextLimit;
  }
  case EM_FINDTEXT:
  case EM_FINDTEXTW:
  {
    FINDTEXTW *ft = (FINDTEXTW *)lParam;
    return ME_FindText(editor, wParam, &ft->chrg, ft->lpstrText, NULL);
  }
  case EM_FINDTEXTEX:
  case EM_FINDTEXTEXW:
  {
    FINDTEXTEXW *ex = (FINDTEXTEXW *)lParam;
    return ME_FindText(editor, wParam, &ex->chrg, ex->lpstrText, &ex->chrgText);
  }
  case EM_GETZOOM:
    if (!wParam || !lParam)
      return FALSE;
    *(int *)wParam = editor->nZoomNumerator;
    *(int *)lParam = editor->nZoomDenominator;
    return TRUE;
  case EM_SETZOOM:
    return ME_SetZoom(editor, wParam, lParam);
  case EM_CHARFROMPOS:
  {
    ME_Cursor cursor;
    if (ME_CharFromPos(editor, ((POINTL *)lParam)->x, ((POINTL *)lParam)->y,
                       &cursor, NULL))
      return ME_GetCursorOfs(&cursor);
    else
      return -1;
  }
  case EM_POSFROMCHAR:
  {
    ME_Cursor cursor;
    int nCharOfs, nLength;
    POINTL pt = {0,0};
 
    nCharOfs = wParam;
    /* detect which API version we're dealing with */
    if (wParam >= 0x40000)
        nCharOfs = lParam;
    nLength = ME_GetTextLength(editor);
    nCharOfs = min(nCharOfs, nLength);
    nCharOfs = max(nCharOfs, 0);
 
    cursor_from_char_ofs( editor, nCharOfs, &cursor );
    pt.y = cursor.run->pt.y;
    pt.x = cursor.run->pt.x +
        ME_PointFromChar( editor, cursor.run, cursor.nOffset, TRUE );
    pt.y += cursor.para->pt.y + editor->rcFormat.top;
    pt.x += editor->rcFormat.left;
 
    pt.x -= editor->horz_si.nPos;
    pt.y -= editor->vert_si.nPos;
 
    if (wParam >= 0x40000) *(POINTL *)wParam = pt;
 
    return (wParam >= 0x40000) ? 0 : MAKELONG( pt.x, pt.y );
  }
  case WM_LBUTTONDBLCLK:
  case WM_LBUTTONDOWN:
  {
    ME_CommitUndo(editor); /* End coalesced undos for typed characters */
    ITextHost_TxSetFocus(editor->texthost);
    ME_LButtonDown(editor, (short)LOWORD(lParam), (short)HIWORD(lParam),
                   ME_CalculateClickCount(editor, msg, wParam, lParam));
    ITextHost_TxSetCapture(editor->texthost, TRUE);
    editor->bMouseCaptured = TRUE;
    link_notify( editor, msg, wParam, lParam );
    break;
  }
  case WM_MOUSEMOVE:
    if (editor->bMouseCaptured)
      ME_MouseMove(editor, (short)LOWORD(lParam), (short)HIWORD(lParam));
    else
      link_notify( editor, msg, wParam, lParam );
    break;
  case WM_LBUTTONUP:
    if (editor->bMouseCaptured) {
      ITextHost_TxSetCapture(editor->texthost, FALSE);
      editor->bMouseCaptured = FALSE;
    }
    if (editor->nSelectionType == stDocument)
      editor->nSelectionType = stPosition;
    else
    {
      link_notify( editor, msg, wParam, lParam );
    }
    break;
  case WM_RBUTTONUP:
  case WM_RBUTTONDOWN:
  case WM_RBUTTONDBLCLK:
    ME_CommitUndo(editor); /* End coalesced undos for typed characters */
    link_notify( editor, msg, wParam, lParam );
    goto do_default;
  case WM_CONTEXTMENU:
    if (!ME_ShowContextMenu(editor, (short)LOWORD(lParam), (short)HIWORD(lParam)))
      goto do_default;
    break;
  case WM_SETFOCUS:
    editor->bHaveFocus = TRUE;
    create_caret(editor);
    update_caret(editor);
    ITextHost_TxNotify( editor->texthost, EN_SETFOCUS, NULL );
    if (!editor->bHideSelection && (editor->props & TXTBIT_HIDESELECTION))
        ME_InvalidateSelection( editor );
    return 0;
  case WM_KILLFOCUS:
    ME_CommitUndo(editor); /* End coalesced undos for typed characters */
    editor->bHaveFocus = FALSE;
    editor->wheel_remain = 0;
    hide_caret(editor);
    DestroyCaret();
    ITextHost_TxNotify( editor->texthost, EN_KILLFOCUS, NULL );
    if (!editor->bHideSelection && (editor->props & TXTBIT_HIDESELECTION))
        ME_InvalidateSelection( editor );
    return 0;
  case WM_COMMAND:
    TRACE("editor wnd command = %d\n", LOWORD(wParam));
    return 0;
  case WM_KEYDOWN:
    if (ME_KeyDown(editor, LOWORD(wParam)))
      return 0;
    goto do_default;
  case WM_CHAR:
    return handle_wm_char( editor, wParam, lParam );
  case WM_UNICHAR:
      if (wParam == UNICODE_NOCHAR) return TRUE;
      if (wParam <= 0x000fffff)
      {
          if (wParam > 0xffff) /* convert to surrogates */
          {
              wParam -= 0x10000;
              handle_wm_char( editor, (wParam >> 10) + 0xd800, 0 );
              handle_wm_char( editor, (wParam & 0x03ff) + 0xdc00, 0 );
          }
          else
              handle_wm_char( editor, wParam, 0 );
      }
      return 0;
  case EM_STOPGROUPTYPING:
    ME_CommitUndo(editor); /* End coalesced undos for typed characters */
    return 0;
  case WM_HSCROLL:
  {
    const int scrollUnit = 7;
 
    switch(LOWORD(wParam))
    {
      case SB_LEFT:
        scroll_abs( editor, 0, 0, TRUE );
        break;
      case SB_RIGHT:
        scroll_abs( editor, editor->horz_si.nMax - (int)editor->horz_si.nPage,
                    editor->vert_si.nMax - (int)editor->vert_si.nPage, TRUE );
        break;
      case SB_LINELEFT:
        ME_ScrollLeft(editor, scrollUnit);
        break;
      case SB_LINERIGHT:
        ME_ScrollRight(editor, scrollUnit);
        break;
      case SB_PAGELEFT:
        ME_ScrollLeft(editor, editor->sizeWindow.cx);
        break;
      case SB_PAGERIGHT:
        ME_ScrollRight(editor, editor->sizeWindow.cx);
        break;
      case SB_THUMBTRACK:
      case SB_THUMBPOSITION:
      {
        int pos = HIWORD(wParam);
        if (editor->horz_si.nMax > 0xffff)
          pos = MulDiv(pos, editor->horz_si.nMax, 0xffff);
        scroll_h_abs( editor, pos, FALSE );
        break;
      }
    }
    break;
  }
  case EM_SCROLL: /* fall through */
  case WM_VSCROLL:
  {
    int origNPos;
    int lineHeight = get_default_line_height( editor );
 
    origNPos = editor->vert_si.nPos;
 
    switch(LOWORD(wParam))
    {
      case SB_TOP:
        scroll_abs( editor, 0, 0, TRUE );
        break;
      case SB_BOTTOM:
        scroll_abs( editor, editor->horz_si.nMax - (int)editor->horz_si.nPage,
                    editor->vert_si.nMax - (int)editor->vert_si.nPage, TRUE );
        break;
      case SB_LINEUP:
        ME_ScrollUp(editor,lineHeight);
        break;
      case SB_LINEDOWN:
        ME_ScrollDown(editor,lineHeight);
        break;
      case SB_PAGEUP:
        ME_ScrollUp(editor,editor->sizeWindow.cy);
        break;
      case SB_PAGEDOWN:
        ME_ScrollDown(editor,editor->sizeWindow.cy);
        break;
      case SB_THUMBTRACK:
      case SB_THUMBPOSITION:
      {
        int pos = HIWORD(wParam);
        if (editor->vert_si.nMax > 0xffff)
          pos = MulDiv(pos, editor->vert_si.nMax, 0xffff);
        scroll_v_abs( editor, pos, FALSE );
        break;
      }
    }
    if (msg == EM_SCROLL)
      return 0x00010000 | (((editor->vert_si.nPos - origNPos)/lineHeight) & 0xffff);
    break;
  }
  case WM_MOUSEWHEEL:
  {
    int delta = GET_WHEEL_DELTA_WPARAM( wParam );
    BOOL ctrl_is_down = GetKeyState( VK_CONTROL ) & 0x8000;
 
    /* if scrolling changes direction, ignore left overs */
    if ((delta < 0 && editor->wheel_remain < 0) ||
        (delta > 0 && editor->wheel_remain > 0))
      editor->wheel_remain += delta;
    else
      editor->wheel_remain = delta;
 
    if (editor->wheel_remain)
    {
      if (ctrl_is_down) {
        int numerator;
        if (!editor->nZoomNumerator || !editor->nZoomDenominator)
        {
          numerator = 100;
        } else {
          numerator = editor->nZoomNumerator * 100 / editor->nZoomDenominator;
        }
        numerator += calc_wheel_change( &editor->wheel_remain, 10 );
        if (numerator >= 10 && numerator <= 500)
          ME_SetZoom(editor, numerator, 100);
      } else {
        UINT max_lines = 3;
        int lines = 0;
 
        SystemParametersInfoW( SPI_GETWHEELSCROLLLINES, 0, &max_lines, 0 );
        if (max_lines)
          lines = calc_wheel_change( &editor->wheel_remain, (int)max_lines );
        if (lines)
          ME_ScrollDown( editor, -lines * get_default_line_height( editor ) );
      }
    }
    break;
  }
  case EM_REQUESTRESIZE:
    ME_SendRequestResize(editor, TRUE);
    return 0;
#ifndef __REACTOS__
  /* IME messages to make richedit controls IME aware */
#endif
  case WM_IME_SETCONTEXT:
#ifdef __REACTOS__
  {
    if (FALSE) /* FIXME: Condition */
      lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW;
 
    if (wParam)
    {
      HIMC hIMC = ImmGetContext(editor->hWnd);
      LPINPUTCONTEXTDX pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
      if (pIC)
      {
        pIC->dwUIFlags &= ~0x40000;
        ImmUnlockIMC(hIMC);
      }
      if (FALSE) /* FIXME: Condition */
        ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
      ImmReleaseContext(editor->hWnd, hIMC);
    }
 
    return DefWindowProcW(editor->hWnd, msg, wParam, lParam);
  }
#endif
  case WM_IME_CONTROL:
#ifdef __REACTOS__
    return DefWindowProcW(editor->hWnd, msg, wParam, lParam);
#endif
  case WM_IME_SELECT:
#ifdef __REACTOS__
    return DefWindowProcW(editor->hWnd, msg, wParam, lParam);
#endif
  case WM_IME_COMPOSITIONFULL:
    return 0;
  case WM_IME_STARTCOMPOSITION:
  {
#ifdef __REACTOS__
    return DefWindowProcW(editor->hWnd, msg, wParam, lParam);
#else
    editor->imeStartIndex=ME_GetCursorOfs(&editor->pCursors[0]);
    ME_DeleteSelection(editor);
    ME_CommitUndo(editor);
    ME_UpdateRepaint(editor, FALSE);
#endif
    return 0;
  }
  case WM_IME_COMPOSITION:
  {
    HIMC hIMC;
 
    ME_Style *style = style_get_insert_style( editor, editor->pCursors );
    hIMC = ITextHost_TxImmGetContext(editor->texthost);
    ME_DeleteSelection(editor);
    ME_SaveTempStyle(editor, style);
    if (lParam & (GCS_RESULTSTR|GCS_COMPSTR))
    {
        LPWSTR lpCompStr = NULL;
        DWORD dwBufLen;
        DWORD dwIndex = lParam & GCS_RESULTSTR;
        if (!dwIndex)
          dwIndex = GCS_COMPSTR;
 
        dwBufLen = ImmGetCompositionStringW(hIMC, dwIndex, NULL, 0);
        lpCompStr = HeapAlloc(GetProcessHeap(),0,dwBufLen + sizeof(WCHAR));
        ImmGetCompositionStringW(hIMC, dwIndex, lpCompStr, dwBufLen);
        lpCompStr[dwBufLen/sizeof(WCHAR)] = 0;
#ifndef __REACTOS__
        ME_InsertTextFromCursor(editor,0,lpCompStr,dwBufLen/sizeof(WCHAR),style);
#endif
        HeapFree(GetProcessHeap(), 0, lpCompStr);
 
#ifndef __REACTOS__
        if (dwIndex == GCS_COMPSTR)
          set_selection_cursors(editor,editor->imeStartIndex,
                          editor->imeStartIndex + dwBufLen/sizeof(WCHAR));
#endif
    }
    ME_ReleaseStyle(style);
    ME_CommitUndo(editor);
    ME_UpdateRepaint(editor, FALSE);
#ifdef __REACTOS__
    return DefWindowProcW(editor->hWnd, msg, wParam, lParam);
#else
    return 0;
#endif
  }
  case WM_IME_ENDCOMPOSITION:
  {
#ifdef __REACTOS__
    return DefWindowProcW(editor->hWnd, msg, wParam, lParam);
#else
    ME_DeleteSelection(editor);
    editor->imeStartIndex=-1;
    return 0;
#endif
  }
  case EM_GETOLEINTERFACE:
    IRichEditOle_AddRef( editor->richole );
    *(IRichEditOle **)lParam = editor->richole;
    return 1;
 
  case EM_SETOLECALLBACK:
    if(editor->lpOleCallback)
      IRichEditOleCallback_Release(editor->lpOleCallback);
    editor->lpOleCallback = (IRichEditOleCallback*)lParam;
    if(editor->lpOleCallback)
      IRichEditOleCallback_AddRef(editor->lpOleCallback);
    return TRUE;
  case EM_GETWORDBREAKPROC:
    return (LRESULT)editor->pfnWordBreak;
  case EM_SETWORDBREAKPROC:
  {
    EDITWORDBREAKPROCW pfnOld = editor->pfnWordBreak;
 
    editor->pfnWordBreak = (EDITWORDBREAKPROCW)lParam;
    return (LRESULT)pfnOld;
  }
  case EM_GETTEXTMODE:
    return editor->mode;
  case EM_SETTEXTMODE:
  {
    int mask = 0;
    int changes = 0;
 
    if (ME_GetTextLength(editor) ||
        !list_empty( &editor->undo_stack ) || !list_empty( &editor->redo_stack ))
      return E_UNEXPECTED;
 
    /* Check for mutually exclusive flags in adjacent bits of wParam */
    if ((wParam & (TM_RICHTEXT | TM_MULTILEVELUNDO | TM_MULTICODEPAGE)) &
        (wParam & (TM_PLAINTEXT | TM_SINGLELEVELUNDO | TM_SINGLECODEPAGE)) << 1)
      return E_INVALIDARG;
 
    if (wParam & (TM_RICHTEXT | TM_PLAINTEXT))
    {
      mask |= TM_RICHTEXT | TM_PLAINTEXT;
      changes |= wParam & (TM_RICHTEXT | TM_PLAINTEXT);
      if (wParam & TM_PLAINTEXT) {
        /* Clear selection since it should be possible to select the
         * end of text run for rich text */
        ME_InvalidateSelection(editor);
        ME_SetCursorToStart(editor, &editor->pCursors[0]);
        editor->pCursors[1] = editor->pCursors[0];
        /* plain text can only have the default style. */
        ME_ClearTempStyle(editor);
        ME_AddRefStyle(editor->pBuffer->pDefaultStyle);
        ME_ReleaseStyle( editor->pCursors[0].run->style );
        editor->pCursors[0].run->style = editor->pBuffer->pDefaultStyle;
      }
    }
    /* FIXME: Currently no support for undo level and code page options */
    editor->mode = (editor->mode & ~mask) | changes;
    return 0;
  }
  case EM_SETTARGETDEVICE:
    if (wParam == 0)
    {
      BOOL new = (lParam == 0 && (editor->props & TXTBIT_MULTILINE));
      if (editor->nAvailWidth || editor->bWordWrap != new)
      {
        editor->bWordWrap = new;
        editor->nAvailWidth = 0; /* wrap to client area */
        ME_RewrapRepaint(editor);
      }
    } else {
      int width = max(0, lParam);
      if ((editor->props & TXTBIT_MULTILINE) &&
          (!editor->bWordWrap || editor->nAvailWidth != width))
      {
        editor->nAvailWidth = width;
        editor->bWordWrap = TRUE;
        ME_RewrapRepaint(editor);
      }
      FIXME("EM_SETTARGETDEVICE doesn't use non-NULL target devices\n");
    }
    return TRUE;
  default:
  do_default:
    *phresult = S_FALSE;
    break;
  }
  return 0L;
}

Referenced by fnTextSrv_TxSendMessage().

◆ editor_mark_rewrap_all()

void editor_mark_rewrap_all ( ME_TextEditor * editor )

Definition at line 237 of file para.c.

{
    para_mark_rewrap_paras( editor, editor_first_para( editor ), editor_end_para( editor ) );
}

Referenced by editor_handle_message(), fnTextSrv_TxDraw(), fnTextSrv_TxGetNaturalSize(), ME_RewrapRepaint(), and ME_SetDefaultCharFormat().

◆ editor_propagate_char_ofs()

void editor_propagate_char_ofs	(	ME_Paragraph *	para,
		ME_Run *	run,
		int	shift
	)

Definition at line 147 of file run.c.

{
    assert( !para ^ !run );
 
    if (run)
    {
        para = para_next( run->para );
        do
        {
            run->nCharOfs += shift;
            run = run_next( run );
        } while (run);
    }
 
    do
    {
        para->nCharOfs += shift;
        para = para_next( para );
    } while (para);
}

Referenced by ME_InternalDeleteText(), para_join(), para_split(), and run_insert().

◆ editor_set_cursor()

void editor_set_cursor	(	ME_TextEditor *	editor,
		int	x,
		int	y
	)

Definition at line 2824 of file editor.c.

{
    ME_Cursor pos;
    BOOL is_exact;
    static HCURSOR cursor_arrow, cursor_hand, cursor_ibeam, cursor_reverse;
    HCURSOR cursor;
 
    if (!cursor_arrow)
    {
        cursor_arrow = LoadCursorW( NULL, MAKEINTRESOURCEW( IDC_ARROW ) );
        cursor_hand = LoadCursorW( NULL, MAKEINTRESOURCEW( IDC_HAND ) );
        cursor_ibeam = LoadCursorW( NULL, MAKEINTRESOURCEW( IDC_IBEAM ) );
        cursor_reverse = LoadCursorW( dll_instance, MAKEINTRESOURCEW( OCR_REVERSE ) );
    }
 
    cursor = cursor_ibeam;
 
    if ((editor->nSelectionType == stLine && editor->bMouseCaptured) ||
        (!editor->bEmulateVersion10 && y < editor->rcFormat.top && x < editor->rcFormat.left))
        cursor = cursor_reverse;
    else if (y < editor->rcFormat.top || y > editor->rcFormat.bottom)
    {
        if (editor->bEmulateVersion10) cursor = cursor_arrow;
        else cursor = cursor_ibeam;
    }
    else if (x < editor->rcFormat.left) cursor = cursor_reverse;
    else
    {
        ME_CharFromPos( editor, x, y, &pos, &is_exact );
        if (is_exact)
        {
            ME_Run *run = pos.run;
 
            if (is_link( run )) cursor = cursor_hand;
 
            else if (ME_IsSelection( editor ))
            {
                int start, end, offset = ME_GetCursorOfs( &pos );
 
                ME_GetSelectionOfs( editor, &start, &end );
                if (start <= offset && end >= offset) cursor = cursor_arrow;
            }
        }
    }
 
    ITextHost_TxSetCursor( editor->texthost, cursor, cursor == cursor_ibeam );
}

Referenced by fnTextSrv_OnTxSetCursor().

◆ editor_set_default_para_fmt()

void editor_set_default_para_fmt	(	ME_TextEditor *	editor,
		PARAFORMAT2 *	pFmt
	)

Definition at line 960 of file para.c.

{
    const PARAFORMAT2 *host_fmt;
    HRESULT hr;
 
    ZeroMemory(pFmt, sizeof(PARAFORMAT2));
    pFmt->cbSize = sizeof(PARAFORMAT2);
    pFmt->dwMask = PFM_ALL2;
    pFmt->wAlignment = PFA_LEFT;
    pFmt->sStyle = -1;
    pFmt->bOutlineLevel = TRUE;
 
    hr = ITextHost_TxGetParaFormat( editor->texthost, (const PARAFORMAT **)&host_fmt );
    if (SUCCEEDED(hr))
    {
        /* Just use the alignment for now */
        if (host_fmt->dwMask & PFM_ALIGNMENT)
            pFmt->wAlignment = host_fmt->wAlignment;
        ITextHost_OnTxParaFormatChange( editor->texthost, (PARAFORMAT *)pFmt );
    }
}

Referenced by handle_enter(), ME_InternalDeleteText(), ME_StreamIn(), and para_create().

◆ editor_set_selection_para_fmt()

BOOL editor_set_selection_para_fmt	(	ME_TextEditor *	editor,
		const PARAFORMAT2 *	fmt
	)

Definition at line 875 of file para.c.

{
    ME_Paragraph *para, *para_end;
 
    editor_get_selection_paras( editor, &para, &para_end );
 
    do
    {
        para_set_fmt( editor, para, fmt );
        if (para == para_end) break;
        para = para_next( para );
    } while(1);
 
    return TRUE;
}

Referenced by editor_handle_message(), and SpecialChar().

◆ get_text()

static WCHAR * get_text	(	const ME_Run *	run,
		int	offset
	)

inlinestatic

Definition at line 42 of file editor.h.

{
    return run->para->text->szData + run->nCharOfs + offset;
}

Referenced by debugstr_run(), draw_paragraph(), draw_text(), editor_handle_message(), ME_CharFromPointContext(), ME_FindNextURLCandidate(), ME_FindText(), ME_GetRunSizeCommon(), ME_GetTextW(), ME_InsertRowStart(), ME_InternalDeleteText(), ME_MaximizeSplit(), ME_MoveCursorWords(), ME_PointFromCharContext(), ME_SplitByBacktracking(), ME_StreamOutRTF(), ME_StreamOutText(), ME_UpdateRunFlags(), ME_WrapHandleRun(), run_is_entirely_ws(), run_is_splittable(), shape_run(), and test_para_numbering().

◆ get_total_width()

int get_total_width ( ME_TextEditor * editor )

Definition at line 69 of file para.c.

{
    ME_Paragraph *para;
    int total_width = 0;
 
    if (editor->pBuffer->pFirst && editor->pBuffer->pLast)
    {
        para = &editor->pBuffer->pFirst->next->member.para;
        while (para != &editor->pBuffer->pLast->member.para && para->next_para)
        {
            total_width = max(total_width, para->nWidth);
            para = &para->next_para->member.para;
        }
    }
 
    return total_width;
}

Referenced by para_destroy(), and wrap_marked_paras_dc().

◆ hide_caret()

void hide_caret ( ME_TextEditor * ed )

Definition at line 267 of file caret.c.

{
  /* calls to HideCaret are cumulative; do so only once */
  if (!editor->caret_hidden)
  {
    ITextHost_TxShowCaret(editor->texthost, FALSE);
    editor->caret_hidden = TRUE;
  }
}

Referenced by editor_handle_message(), ME_ArrowKey(), and update_caret().

◆ link_notify()

void link_notify	(	ME_TextEditor *	editor,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 3122 of file editor.c.

{
  int x,y;
  BOOL isExact;
  ME_Cursor cursor; /* The start of the clicked text. */
  ME_Run *run;
  ENLINK info;
 
  x = (short)LOWORD(lParam);
  y = (short)HIWORD(lParam);
  ME_CharFromPos(editor, x, y, &cursor, &isExact);
  if (!isExact) return;
 
  if (is_link( cursor.run ))
  { /* The clicked run has CFE_LINK set */
    info.nmhdr.hwndFrom = NULL;
    info.nmhdr.idFrom = 0;
    info.nmhdr.code = EN_LINK;
    info.msg = msg;
    info.wParam = wParam;
    info.lParam = lParam;
    cursor.nOffset = 0;
 
    /* find the first contiguous run with CFE_LINK set */
    info.chrg.cpMin = ME_GetCursorOfs(&cursor);
    run = cursor.run;
    while ((run = run_prev( run )) && is_link( run ))
        info.chrg.cpMin -= run->len;
 
    /* find the last contiguous run with CFE_LINK set */
    info.chrg.cpMax = ME_GetCursorOfs(&cursor) + cursor.run->len;
    run = cursor.run;
    while ((run = run_next( run )) && is_link( run ))
        info.chrg.cpMax += run->len;
 
    ITextHost_TxNotify(editor->texthost, info.nmhdr.code, &info);
  }
}

Referenced by editor_handle_message(), and fnTextSrv_OnTxSetCursor().

◆ ME_AddRefStyle()

void ME_AddRefStyle ( ME_Style * item )

Definition at line 454 of file style.c.

{
  assert(s->nRefs>0); /* style with 0 references isn't supposed to exist */
  s->nRefs++;
  all_refs++;
  TRACE_(richedit_style)("ME_AddRefStyle %p, new refs=%d, total refs=%d\n", s, s->nRefs, all_refs);
}

Referenced by add_undo_insert_run(), editor_handle_message(), ME_ApplyStyle(), ME_RTFReadHook(), ME_SaveTempStyle(), ME_StreamIn(), para_num_init(), RTFUngetToken(), run_create(), and style_get_insert_style().

◆ ME_AppendString()

BOOL ME_AppendString	(	ME_String *	s,
		const WCHAR *	append,
		int	len
	)

Definition at line 126 of file string.c.

{
    return ME_InsertString( s, s->nLen, append, len );
}

Referenced by para_join(), and para_split().

◆ ME_ApplyStyle()

ME_Style * ME_ApplyStyle	(	ME_TextEditor *	ed,
		ME_Style *	sSrc,
		CHARFORMAT2W *	style
	)

Definition at line 156 of file style.c.

{
  CHARFORMAT2W fmt = sSrc->fmt;
  ME_Style *s;
 
  assert(mod->cbSize == sizeof(CHARFORMAT2W));
  COPY_STYLE_ITEM(CFM_ANIMATION, bAnimation);
  COPY_STYLE_ITEM(CFM_BACKCOLOR, crBackColor);
  COPY_STYLE_ITEM(CFM_CHARSET, bCharSet);
  COPY_STYLE_ITEM(CFM_COLOR, crTextColor);
  COPY_STYLE_ITEM_MEMCPY(CFM_FACE, szFaceName);
  COPY_STYLE_ITEM(CFM_KERNING, wKerning);
  COPY_STYLE_ITEM(CFM_LCID, lcid);
  COPY_STYLE_ITEM(CFM_OFFSET, yOffset);
  COPY_STYLE_ITEM(CFM_REVAUTHOR, bRevAuthor);
  if (mod->dwMask & CFM_SIZE) {
    fmt.dwMask |= CFM_SIZE;
    fmt.yHeight = min(mod->yHeight, yHeightCharPtsMost * 20);
  }
  COPY_STYLE_ITEM(CFM_SPACING, sSpacing);
  COPY_STYLE_ITEM(CFM_STYLE, sStyle);
  COPY_STYLE_ITEM(CFM_WEIGHT, wWeight);
  /* FIXME: this is not documented this way, but that's the more logical */
  COPY_STYLE_ITEM(CFM_FACE, bPitchAndFamily);
 
  fmt.dwEffects &= ~(mod->dwMask);
  fmt.dwEffects |= mod->dwEffects & mod->dwMask;
  fmt.dwMask |= mod->dwMask;
  if (mod->dwMask & CFM_COLOR)
  {
    if (mod->dwEffects & CFE_AUTOCOLOR)
      fmt.dwEffects |= CFE_AUTOCOLOR;
    else
      fmt.dwEffects &= ~CFE_AUTOCOLOR;
  }
 
  COPY_STYLE_ITEM(CFM_UNDERLINETYPE, bUnderlineType);
  /* If the CFM_UNDERLINE effect is not specified, set it appropriately */
  if ((mod->dwMask & CFM_UNDERLINETYPE) && !(mod->dwMask & CFM_UNDERLINE))
  {
      fmt.dwMask |= CFM_UNDERLINE;
      if (mod->bUnderlineType == CFU_UNDERLINENONE)
          fmt.dwEffects &= ~CFE_UNDERLINE;
      else
          fmt.dwEffects |= CFE_UNDERLINE;
  }
 
  if (mod->dwMask & CFM_BOLD && !(mod->dwMask & CFM_WEIGHT))
  {
      fmt.wWeight = (mod->dwEffects & CFE_BOLD) ? FW_BOLD : FW_NORMAL;
  } else if (mod->dwMask & CFM_WEIGHT && !(mod->dwMask & CFM_BOLD)) {
      if (mod->wWeight > FW_NORMAL)
          fmt.dwEffects |= CFE_BOLD;
      else
          fmt.dwEffects &= ~CFE_BOLD;
  }
 
  LIST_FOR_EACH_ENTRY(s, &editor->style_list, ME_Style, entry)
  {
      if (!memcmp( &s->fmt, &fmt, sizeof(fmt) ))
      {
          TRACE_(richedit_style)("found existing style %p\n", s);
          ME_AddRefStyle( s );
          return s;
      }
  }
 
  s = ME_MakeStyle( &fmt );
  if (s)
      list_add_head( &editor->style_list, &s->entry );
  TRACE_(richedit_style)("created new style %p\n", s);
  return s;
}

Referenced by ME_RTFCharAttrHook(), ME_SetCharFormat(), ME_SetDefaultCharFormat(), ME_SetSelectionCharFormat(), and para_num_init().

◆ ME_ArrowKey()

BOOL ME_ArrowKey	(	ME_TextEditor *	ed,
		int	nVKey,
		BOOL	extend,
		BOOL	ctrl
	)

Definition at line 1452 of file caret.c.

{
  int nCursor = 0;
  ME_Cursor *p = &editor->pCursors[nCursor];
  ME_Cursor tmp_curs = *p;
  BOOL success = FALSE;
 
  ME_CheckCharOffsets(editor);
  switch(nVKey) {
    case VK_LEFT:
      if (ctrl)
        success = ME_MoveCursorWords(editor, &tmp_curs, -1);
      else
        success = ME_MoveCursorChars(editor, &tmp_curs, -1, extend);
      break;
    case VK_RIGHT:
      if (ctrl)
        success = ME_MoveCursorWords(editor, &tmp_curs, +1);
      else
        success = ME_MoveCursorChars(editor, &tmp_curs, +1, extend);
      break;
    case VK_UP:
      cursor_move_line( editor, &tmp_curs, TRUE, extend );
      break;
    case VK_DOWN:
      cursor_move_line( editor, &tmp_curs, FALSE, extend );
      break;
    case VK_PRIOR:
      ME_ArrowPageUp(editor, &tmp_curs);
      break;
    case VK_NEXT:
      ME_ArrowPageDown(editor, &tmp_curs);
      break;
    case VK_HOME: {
      if (ctrl)
        ME_ArrowCtrlHome(editor, &tmp_curs);
      else
        ME_ArrowHome(editor, &tmp_curs);
      break;
    }
    case VK_END:
      if (ctrl)
        ME_ArrowCtrlEnd(editor, &tmp_curs);
      else
        ME_ArrowEnd(editor, &tmp_curs);
      break;
  }
 
  if (!extend)
    editor->pCursors[1] = tmp_curs;
  *p = tmp_curs;
 
  ME_InvalidateSelection(editor);
  ME_Repaint(editor);
  hide_caret(editor);
  editor_ensure_visible( editor, &tmp_curs );
  update_caret(editor);
  ME_SendSelChange(editor);
  return success;
}

Referenced by ME_KeyDown().

◆ ME_CallWordBreakProc()

int ME_CallWordBreakProc	(	ME_TextEditor *	editor,
		WCHAR *	str,
		INT	len,
		INT	start,
		INT	code
	)

Definition at line 204 of file string.c.

{
  if (!editor->pfnWordBreak) {
    return ME_WordBreakProc(str, start, len, code);
  } else if (!editor->bEmulateVersion10) {
    /* MSDN lied about the third parameter for EditWordBreakProc being the number
     * of characters, it is actually the number of bytes of the string. */
    return editor->pfnWordBreak(str, start, len * sizeof(WCHAR), code);
  } else {
    int result;
    int buffer_size = WideCharToMultiByte(CP_ACP, 0, str, len,
                                          NULL, 0, NULL, NULL);
    char *buffer = heap_alloc(buffer_size);
    if (!buffer) return 0;
    WideCharToMultiByte(CP_ACP, 0, str, len,
                        buffer, buffer_size, NULL, NULL);
    result = editor->pfnWordBreak((WCHAR*)buffer, start, buffer_size, code);
    heap_free(buffer);
    return result;
  }
}

Referenced by ME_MoveCursorWords().

◆ ME_CanJoinRuns()

BOOL ME_CanJoinRuns	(	const ME_Run *	run1,
		const ME_Run *	run2
	)

Definition at line 129 of file run.c.

{
  if ((run1->nFlags | run2->nFlags) & MERF_NOJOIN)
    return FALSE;
  if (run1->style != run2->style)
    return FALSE;
  if ((run1->nFlags & MERF_STYLEFLAGS) != (run2->nFlags & MERF_STYLEFLAGS))
    return FALSE;
  return TRUE;
}

Referenced by ME_PrepareParagraphForWrapping().

◆ ME_CharCompare()

static int ME_CharCompare	(	WCHAR	a,
		WCHAR	b,
		int	caseSensitive
	)

inlinestatic

Definition at line 104 of file editor.h.

{
  return caseSensitive ? (a == b) : (towupper(a) == towupper(b));
}

Referenced by ME_FindText().

◆ ME_CharFormatFromLogFont()

void ME_CharFormatFromLogFont	(	HDC	hDC,
		const LOGFONTW *	lf,
		CHARFORMAT2W *	fmt
	)

Definition at line 331 of file style.c.

{
  int ry;
 
  ME_InitCharFormat2W(fmt);
  ry = GetDeviceCaps(hDC, LOGPIXELSY);
  lstrcpyW(fmt->szFaceName, lf->lfFaceName);
  fmt->dwEffects = 0;
  fmt->dwMask = CFM_WEIGHT|CFM_BOLD|CFM_ITALIC|CFM_UNDERLINE|CFM_UNDERLINETYPE|CFM_STRIKEOUT|CFM_SIZE|CFM_FACE|CFM_CHARSET;
  fmt->wWeight = lf->lfWeight;
  fmt->yHeight = -lf->lfHeight*1440/ry;
  if (lf->lfWeight > FW_NORMAL) fmt->dwEffects |= CFM_BOLD;
  if (lf->lfItalic) fmt->dwEffects |= CFM_ITALIC;
  if (lf->lfUnderline) fmt->dwEffects |= CFM_UNDERLINE;
  fmt->bUnderlineType = CFU_UNDERLINE;
  if (lf->lfStrikeOut) fmt->dwEffects |= CFM_STRIKEOUT;
  fmt->bPitchAndFamily = lf->lfPitchAndFamily;
  fmt->bCharSet = lf->lfCharSet;
}

Referenced by editor_handle_message().

◆ ME_CharFromPoint()

int ME_CharFromPoint	(	ME_TextEditor *	editor,
		int	cx,
		ME_Run *	run,
		BOOL	closest,
		BOOL	visual_order
	)

Definition at line 570 of file run.c.

{
    ME_Context c;
    int ret;
    HDC hdc = ITextHost_TxGetDC( editor->texthost );
 
    ME_InitContext( &c, editor, hdc );
    ret = ME_CharFromPointContext( &c, cx, run, closest, visual_order );
    ME_DestroyContext(&c);
    ITextHost_TxReleaseDC( editor->texthost, hdc );
    return ret;
}

Referenced by row_cursor().

◆ ME_CharFromPointContext()

int ME_CharFromPointContext	(	ME_Context *	c,
		int	cx,
		ME_Run *	run,
		BOOL	closest,
		BOOL	visual_order
	)

Definition at line 511 of file run.c.

{
  ME_String *mask_text = NULL;
  WCHAR *str;
  int fit = 0;
  SIZE sz, sz2, sz3;
  if (!run->len || cx <= 0)
    return 0;
 
  if (run->nFlags & (MERF_TAB | MERF_ENDCELL))
  {
    if (!closest || cx < run->nWidth / 2) return 0;
    return 1;
  }
 
  if (run->nFlags & MERF_GRAPHICS)
  {
    SIZE sz;
    ME_GetOLEObjectSize(c, run, &sz);
    if (!closest || cx < sz.cx / 2) return 0;
    return 1;
  }
 
  if (run->para->nFlags & MEPF_COMPLEX)
  {
      int cp, trailing;
      if (visual_order && run->script_analysis.fRTL) cx = run->nWidth - cx - 1;
 
      ScriptXtoCP( cx, run->len, run->num_glyphs, run->clusters, run->vis_attrs, run->advances, &run->script_analysis,
                   &cp, &trailing );
      TRACE("x %d cp %d trailing %d (run width %d) rtl %d log order %d\n", cx, cp, trailing, run->nWidth,
            run->script_analysis.fRTL, run->script_analysis.fLogicalOrder);
      return closest ? cp + trailing : cp;
  }
 
  if (c->editor->password_char)
  {
    mask_text = ME_MakeStringR( c->editor->password_char, run->len );
    str = mask_text->szData;
  }
  else
    str = get_text( run, 0 );
 
  select_style(c, run->style);
  GetTextExtentExPointW(c->hDC, str, run->len,
                        cx, &fit, NULL, &sz);
  if (closest && fit != run->len)
  {
    GetTextExtentPoint32W(c->hDC, str, fit, &sz2);
    GetTextExtentPoint32W(c->hDC, str, fit + 1, &sz3);
    if (cx >= (sz2.cx+sz3.cx)/2)
      fit = fit + 1;
  }
 
  ME_DestroyString( mask_text );
 
  return fit;
}

Referenced by find_split_point(), and ME_CharFromPoint().

◆ ME_CharFromPos()

BOOL ME_CharFromPos	(	ME_TextEditor *	editor,
		int	x,
		int	y,
		ME_Cursor *	cursor,
		BOOL *	isExact
	)

Definition at line 1039 of file caret.c.

{
  RECT rc;
  BOOL bResult;
 
  ITextHost_TxGetClientRect(editor->texthost, &rc);
  if (x < 0 || y < 0 || x >= rc.right || y >= rc.bottom) {
    if (isExact) *isExact = FALSE;
    return FALSE;
  }
  x += editor->horz_si.nPos;
  y += editor->vert_si.nPos;
  bResult = cursor_from_virtual_coords( editor, x, y, cursor, FALSE );
  if (isExact) *isExact = bResult;
  return TRUE;
}

Referenced by editor_handle_message(), editor_set_cursor(), and link_notify().

◆ ME_CheckCharOffsets()

void ME_CheckCharOffsets ( ME_TextEditor * editor )

Definition at line 173 of file run.c.

{
  ME_DisplayItem *p = editor->pBuffer->pFirst;
  int ofs = 0, ofsp = 0;
 
  if (!TRACE_ON(richedit_check))
    return;
 
  TRACE_(richedit_check)("Checking begin\n");
  if(TRACE_ON(richedit_lists))
  {
    TRACE_(richedit_lists)("---\n");
    ME_DumpDocument(editor->pBuffer);
  }
  do {
    p = ME_FindItemFwd(p, diRunOrParagraphOrEnd);
    switch(p->type) {
      case diTextEnd:
        TRACE_(richedit_check)("tend, real ofsp = %d, counted = %d\n", p->member.para.nCharOfs, ofsp+ofs);
        assert(ofsp+ofs == p->member.para.nCharOfs);
        TRACE_(richedit_check)("Checking finished\n");
        return;
      case diParagraph:
        TRACE_(richedit_check)("para, real ofsp = %d, counted = %d\n", p->member.para.nCharOfs, ofsp+ofs);
        assert(ofsp+ofs == p->member.para.nCharOfs);
        ofsp = p->member.para.nCharOfs;
        ofs = 0;
        break;
      case diRun:
        TRACE_(richedit_check)("run, real ofs = %d (+ofsp = %d), counted = %d, len = %d, txt = %s, flags=%08x, fx&mask = %08x\n",
          p->member.run.nCharOfs, p->member.run.nCharOfs+ofsp, ofsp+ofs,
          p->member.run.len, debugstr_run( &p->member.run ),
          p->member.run.nFlags,
          p->member.run.style->fmt.dwMask & p->member.run.style->fmt.dwEffects);
        assert(ofs == p->member.run.nCharOfs);
        assert(p->member.run.len);
        ofs += p->member.run.len;
        break;
      case diCell:
        TRACE_(richedit_check)("cell\n");
        break;
      default:
        assert(0);
    }
  } while(1);
  TRACE_(richedit_check)("Checking finished\n");
}

Referenced by ME_ArrowKey(), ME_InternalDeleteText(), ME_KeyDown(), ME_MakeEditor(), para_join(), run_join(), and split_run_extents().

◆ ME_ClearTempStyle()

void ME_ClearTempStyle ( ME_TextEditor * editor )

Definition at line 507 of file style.c.

{
  if (!editor->pBuffer->pCharStyle) return;
  ME_ReleaseStyle(editor->pBuffer->pCharStyle);
  editor->pBuffer->pCharStyle = NULL;
}

Referenced by editor_handle_message(), ME_DestroyEditor(), ME_ReplaceSel(), ME_SendSelChange(), and ME_StreamIn().

◆ ME_CommitCoalescingUndo()

void ME_CommitCoalescingUndo ( ME_TextEditor * editor )

Commits preceding changes into a undo transaction that can be expanded.

This function allows the transaction to be reopened with ME_ContinueCoalescingTransaction in order to continue the transaction. If an undo item is added to the undo stack as a result of a change without the transaction being reopened, then the transaction will be ended, and the changes will become a part of the next transaction.

This is used to allow typed characters to be grouped together since each typed character results in a single event, and each event adding undo items must be committed. Using this function as opposed to ME_CommitUndo allows multiple events to be grouped, and undone together.

Definition at line 301 of file undo.c.

{
  struct undo_item *item;
  struct list *head;
 
  if (editor->nUndoMode == umIgnore)
    return;
 
  assert(editor->nUndoMode == umAddToUndo);
 
  head = list_head( &editor->undo_stack );
  if (!head) return;
 
  /* no need to commit empty transactions */
  item = LIST_ENTRY( head, struct undo_item, entry );
  if (item->type == undo_end_transaction ||
      item->type == undo_potential_end_transaction)
      return;
 
  add_undo( editor, undo_potential_end_transaction );
}

Referenced by handle_enter(), handle_wm_char(), and ME_KeyDown().

◆ ME_CommitUndo()

void ME_CommitUndo ( ME_TextEditor * editor )

Commits preceding changes into a transaction that can be undone together.

This should be called after all the changes occur associated with an event so that the group of changes can be undone atomically as a transaction.

This will have no effect the undo mode is set to ignore changes, or if no changes preceded calling this function before the last time it was called.

This can also be used to conclude a coalescing transaction (used for grouping typed characters).

Definition at line 227 of file undo.c.

{
  struct undo_item *item;
  struct list *head;
 
  if (editor->nUndoMode == umIgnore)
    return;
  
  assert(editor->nUndoMode == umAddToUndo);
  
  /* no transactions, no need to commit */
  head = list_head( &editor->undo_stack );
  if (!head) return;
 
  /* no need to commit empty transactions */
  item = LIST_ENTRY( head, struct undo_item, entry );
  if (item->type == undo_end_transaction) return;
 
  if (item->type == undo_potential_end_transaction)
  {
      item->type = undo_end_transaction;
      return;
  }
 
  add_undo( editor, undo_end_transaction );
}

Referenced by editor_copy_or_cut(), editor_handle_message(), handle_EM_SETCHARFORMAT(), handle_enter(), handle_wm_char(), IRichEditOle_fnInsertObject(), ME_KeyDown(), ME_ReplaceSel(), ME_StreamIn(), and paste_emf().

◆ ME_ContinueCoalescingTransaction()

void ME_ContinueCoalescingTransaction ( ME_TextEditor * editor )

Groups subsequent changes with previous ones for an undo if coalescing.

Has no effect if the previous changes were followed by a ME_CommitUndo. This function will only have an affect if the previous changes were followed by a call to ME_CommitCoalescingUndo, which allows the transaction to be continued.

This allows multiple consecutively typed characters to be grouped together to be undone by a single undo operation.

Definition at line 265 of file undo.c.

{
  struct undo_item *item;
  struct list *head;
 
  if (editor->nUndoMode == umIgnore)
    return;
 
  assert(editor->nUndoMode == umAddToUndo);
 
  head = list_head( &editor->undo_stack );
  if (!head) return;
 
  item = LIST_ENTRY( head, struct undo_item, entry );
  if (item->type == undo_potential_end_transaction)
  {
    list_remove( &item->entry );
    editor->nUndoStackSize--;
    destroy_undo_item( item );
  }
}

Referenced by handle_enter(), handle_wm_char(), and ME_KeyDown().

◆ ME_CopyCharFormat()

void ME_CopyCharFormat	(	CHARFORMAT2W *	pDest,
		const CHARFORMAT2W *	pSrc
	)

Definition at line 230 of file style.c.

{
  /* using this with non-2W structs is forbidden */
  assert(pSrc->cbSize == sizeof(CHARFORMAT2W));
  assert(pDest->cbSize == sizeof(CHARFORMAT2W));
  *pDest = *pSrc;
}

Referenced by ME_GetDefaultCharFormat(), ME_GetSelectionCharFormat(), and run_copy_char_fmt().

◆ ME_CopyReObject()

void ME_CopyReObject	(	REOBJECT *	dst,
		const REOBJECT *	src,
		DWORD	flags
	)

Definition at line 5829 of file richole.c.

{
    *dst = *src;
    dst->poleobj = NULL;
    dst->pstg = NULL;
    dst->polesite = NULL;
 
    if ((flags & REO_GETOBJ_POLEOBJ) && src->poleobj)
    {
        dst->poleobj = src->poleobj;
        IOleObject_AddRef(dst->poleobj);
    }
    if ((flags & REO_GETOBJ_PSTG) && src->pstg)
    {
        dst->pstg = src->pstg;
        IStorage_AddRef(dst->pstg);
    }
    if ((flags & REO_GETOBJ_POLESITE) && src->polesite)
    {
        dst->polesite = src->polesite;
        IOleClientSite_AddRef(dst->polesite);
    }
}

Referenced by create_re_object(), and IRichEditOle_fnGetObject().

◆ ME_DeleteReObject()

void ME_DeleteReObject ( struct re_object * re_object )

Definition at line 5821 of file richole.c.

{
    if (reobj->obj.poleobj)   IOleObject_Release(reobj->obj.poleobj);
    if (reobj->obj.pstg)      IStorage_Release(reobj->obj.pstg);
    if (reobj->obj.polesite)  IOleClientSite_Release(reobj->obj.polesite);
    heap_free(reobj);
}

Referenced by ME_DestroyDisplayItem().

◆ ME_DeleteSelection()

void ME_DeleteSelection ( ME_TextEditor * editor )

Definition at line 1406 of file caret.c.

{
  int from, to;
  int nStartCursor = ME_GetSelectionOfs(editor, &from, &to);
  int nEndCursor = nStartCursor ^ 1;
  ME_DeleteTextAtCursor(editor, nStartCursor, to - from);
  editor->pCursors[nEndCursor] = editor->pCursors[nStartCursor];
}

Referenced by editor_handle_message(), ME_InsertEndRowFromCursor(), ME_InsertOLEFromCursor(), ME_InsertTextFromCursor(), and ME_KeyDown().

◆ ME_DeleteTextAtCursor()

BOOL ME_DeleteTextAtCursor	(	ME_TextEditor *	editor,
		int	nCursor,
		int	nChars
	)

Definition at line 481 of file caret.c.

{
  assert(nCursor>=0 && nCursor<editor->nCursors);
  /* text operations set modified state */
  editor->nModifyStep = 1;
  return ME_InternalDeleteText(editor, &editor->pCursors[nCursor],
                               nChars, FALSE);
}

Referenced by ME_DeleteSelection(), and ME_KeyDown().

◆ ME_DestroyContext()

void ME_DestroyContext ( ME_Context * c )

Definition at line 44 of file context.c.

{
    select_style( c, NULL );
    if (c->hDC) ITextHost_TxReleaseDC( c->editor->texthost, c->hDC );
}

Referenced by cursor_coords(), editor_draw(), ME_CharFromPoint(), ME_MakeFirstParagraph(), ME_PointFromChar(), stream_out_graphics(), and wrap_marked_paras_dc().

◆ ME_DestroyDisplayItem()

void ME_DestroyDisplayItem ( ME_DisplayItem * item )

Definition at line 115 of file list.c.

{
  if (0)
    TRACE("type=%s\n", ME_GetDITypeName(item->type));
  if (item->type==diRun)
  {
    if (item->member.run.reobj)
    {
      list_remove(&item->member.run.reobj->entry);
      ME_DeleteReObject(item->member.run.reobj);
    }
    heap_free( item->member.run.glyphs );
    heap_free( item->member.run.clusters );
    ME_ReleaseStyle(item->member.run.style);
  }
  heap_free(item);
}

Referenced by ME_DestroyEditor(), ME_InternalDeleteText(), ME_PrepareParagraphForWrapping(), para_destroy(), para_join(), and run_join().

◆ ME_DestroyEditor()

void ME_DestroyEditor ( ME_TextEditor * editor )

Definition at line 3066 of file editor.c.

{
  ME_DisplayItem *p = editor->pBuffer->pFirst, *pNext = NULL;
  ME_Style *s, *cursor2;
  int i;
 
  ME_ClearTempStyle(editor);
  ME_EmptyUndoStack(editor);
  editor->pBuffer->pFirst = NULL;
  while(p)
  {
    pNext = p->next;
    if (p->type == diParagraph)
      para_destroy( editor, &p->member.para );
    else
      ME_DestroyDisplayItem(p);
    p = pNext;
  }
 
  LIST_FOR_EACH_ENTRY_SAFE( s, cursor2, &editor->style_list, ME_Style, entry )
      ME_DestroyStyle( s );
 
  ME_ReleaseStyle(editor->pBuffer->pDefaultStyle);
  for (i=0; i<HFONT_CACHE_SIZE; i++)
  {
    if (editor->pFontCache[i].hFont)
      DeleteObject(editor->pFontCache[i].hFont);
  }
  if(editor->lpOleCallback)
    IRichEditOleCallback_Release(editor->lpOleCallback);
 
  OleUninitialize();
 
  heap_free(editor->pBuffer);
  heap_free(editor->pCursors);
  heap_free(editor);
}

Referenced by ITextServicesImpl_Release().

◆ ME_DestroyString()

void ME_DestroyString ( ME_String * s )

Definition at line 96 of file string.c.

{
  if (!s) return;
  if (s->free) s->free( s );
  heap_free( s );
}

Referenced by destroy_undo_item(), draw_text(), ME_CharFromPointContext(), ME_GetRunSizeCommon(), ME_PointFromCharContext(), para_destroy(), and para_num_clear().

◆ ME_DestroyStyle()

void ME_DestroyStyle ( ME_Style * item )

Definition at line 442 of file style.c.

{
  list_remove( &s->entry );
  if (s->font_cache)
  {
    release_font_cache( s->font_cache );
    s->font_cache = NULL;
  }
  ScriptFreeCache( &s->script_cache );
  heap_free(s);
}

Referenced by ME_DestroyEditor(), and ME_ReleaseStyle().

◆ ME_DumpDocument()

void ME_DumpDocument ( ME_TextBuffer * buffer )

Definition at line 142 of file list.c.

{
  /* FIXME this is useless, */
  ME_DisplayItem *pItem = buffer->pFirst;
  TRACE("DOCUMENT DUMP START\n");
  while(pItem) {
    switch(pItem->type)
    {
      case diTextStart:
        TRACE("Start\n");
        break;
      case diCell:
        TRACE("Cell(level=%d%s)\n", pItem->member.cell.nNestingLevel,
              !pItem->member.cell.next_cell ? ", END" :
                (!pItem->member.cell.prev_cell ? ", START" :""));
        break;
      case diParagraph:
        TRACE("Paragraph(ofs=%d)\n", pItem->member.para.nCharOfs);
        if (pItem->member.para.nFlags & MEPF_ROWSTART)
          TRACE(" - (Table Row Start)\n");
        if (pItem->member.para.nFlags & MEPF_ROWEND)
          TRACE(" - (Table Row End)\n");
        break;
      case diStartRow:
        TRACE(" - StartRow\n");
        break;
      case diRun:
        TRACE(" - Run(%s, %d, flags=%x)\n", debugstr_run( &pItem->member.run ),
          pItem->member.run.nCharOfs, pItem->member.run.nFlags);
        break;
      case diTextEnd:
        TRACE("End(ofs=%d)\n", pItem->member.para.nCharOfs);
        break;
      default:
        break;
    }
    pItem = pItem->next;
  }
  TRACE("DOCUMENT DUMP END\n");
}

Referenced by ME_CheckCharOffsets().

◆ ME_DumpParaStyle()

void ME_DumpParaStyle ( ME_Paragraph * s )

◆ ME_DumpParaStyleToBuf()

void ME_DumpParaStyleToBuf	(	const PARAFORMAT2 *	pFmt,
		char	buf[2048]
	)

Definition at line 787 of file para.c.

{
  char *p;
  p = buf;
 
#define DUMP(mask, name, fmt, field) \
  if (pFmt->dwMask & (mask)) p += sprintf(p, "%-22s" fmt "\n", name, pFmt->field); \
  else p += sprintf(p, "%-22sN/A\n", name);
 
/* we take for granted that PFE_xxx is the hiword of the corresponding PFM_xxx */
#define DUMP_EFFECT(mask, name) \
  p += sprintf(p, "%-22s%s\n", name, (pFmt->dwMask & (mask)) ? ((pFmt->wEffects & ((mask) >> 16)) ? "yes" : "no") : "N/A");
 
  DUMP(PFM_NUMBERING,      "Numbering:",         "%u", wNumbering);
  DUMP_EFFECT(PFM_DONOTHYPHEN,     "Disable auto-hyphen:");
  DUMP_EFFECT(PFM_KEEP,            "No page break in para:");
  DUMP_EFFECT(PFM_KEEPNEXT,        "No page break in para & next:");
  DUMP_EFFECT(PFM_NOLINENUMBER,    "No line number:");
  DUMP_EFFECT(PFM_NOWIDOWCONTROL,  "No widow & orphan:");
  DUMP_EFFECT(PFM_PAGEBREAKBEFORE, "Page break before:");
  DUMP_EFFECT(PFM_RTLPARA,         "RTL para:");
  DUMP_EFFECT(PFM_SIDEBYSIDE,      "Side by side:");
  DUMP_EFFECT(PFM_TABLE,           "Table:");
  DUMP(PFM_OFFSETINDENT,   "Offset indent:",     "%d", dxStartIndent);
  DUMP(PFM_STARTINDENT,    "Start indent:",      "%d", dxStartIndent);
  DUMP(PFM_RIGHTINDENT,    "Right indent:",      "%d", dxRightIndent);
  DUMP(PFM_OFFSET,         "Offset:",            "%d", dxOffset);
  if (pFmt->dwMask & PFM_ALIGNMENT) {
    switch (pFmt->wAlignment) {
    case PFA_LEFT   : p += sprintf(p, "Alignment:            left\n"); break;
    case PFA_RIGHT  : p += sprintf(p, "Alignment:            right\n"); break;
    case PFA_CENTER : p += sprintf(p, "Alignment:            center\n"); break;
    case PFA_JUSTIFY: p += sprintf(p, "Alignment:            justify\n"); break;
    default         : p += sprintf(p, "Alignment:            incorrect %d\n", pFmt->wAlignment); break;
    }
  }
  else p += sprintf(p, "Alignment:            N/A\n");
  DUMP(PFM_TABSTOPS,       "Tab Stops:",         "%d", cTabCount);
  if (pFmt->dwMask & PFM_TABSTOPS) {
    int i;
    p += sprintf(p, "\t");
    for (i = 0; i < pFmt->cTabCount; i++) p += sprintf(p, "%x ", pFmt->rgxTabs[i]);
    p += sprintf(p, "\n");
  }
  DUMP(PFM_SPACEBEFORE,    "Space Before:",      "%d", dySpaceBefore);
  DUMP(PFM_SPACEAFTER,     "Space After:",       "%d", dySpaceAfter);
  DUMP(PFM_LINESPACING,    "Line spacing:",      "%d", dyLineSpacing);
  DUMP(PFM_STYLE,          "Text style:",        "%d", sStyle);
  DUMP(PFM_LINESPACING,    "Line spacing rule:", "%u", bLineSpacingRule);
  /* bOutlineLevel should be 0 */
  DUMP(PFM_SHADING,        "Shading Weight:",    "%u", wShadingWeight);
  DUMP(PFM_SHADING,        "Shading Style:",     "%u", wShadingStyle);
  DUMP(PFM_NUMBERINGSTART, "Numbering Start:",   "%u", wNumberingStart);
  DUMP(PFM_NUMBERINGSTYLE, "Numbering Style:",   "0x%x", wNumberingStyle);
  DUMP(PFM_NUMBERINGTAB,   "Numbering Tab:",     "%u", wNumberingStyle);
  DUMP(PFM_BORDER,         "Border Space:",      "%u", wBorderSpace);
  DUMP(PFM_BORDER,         "Border Width:",      "%u", wBorderWidth);
  DUMP(PFM_BORDER,         "Borders:",           "%u", wBorders);
 
#undef DUMP
#undef DUMP_EFFECT
}

◆ ME_DumpStyle()

void ME_DumpStyle ( ME_Style * s )

Definition at line 243 of file style.c.

{
  char buf[2048];
  ME_DumpStyleToBuf(&s->fmt, buf);
  TRACE_(richedit_style)("%s\n", buf);
}

◆ ME_DumpStyleToBuf()

void ME_DumpStyleToBuf	(	CHARFORMAT2W *	pFmt,
		char	buf[2048]
	)

Definition at line 250 of file style.c.

{
  /* FIXME only CHARFORMAT styles implemented */
  /* this function sucks, doesn't check for buffer overruns but it's "good enough" as for debug code */
  char *p;
  p = buf;
  p += sprintf(p, "Font face:            ");
  if (pFmt->dwMask & CFM_FACE) {
    WCHAR *q = pFmt->szFaceName;
    while(*q) {
      *p++ = (*q > 255) ? '?' : *q;
      q++;      
    }       
  } else
    p += sprintf(p, "N/A");
 
  if (pFmt->dwMask & CFM_SIZE)
    p += sprintf(p, "\nFont size:            %d\n", pFmt->yHeight);
  else
    p += sprintf(p, "\nFont size:            N/A\n");
 
  if (pFmt->dwMask & CFM_OFFSET)
    p += sprintf(p, "Char offset:          %d\n", pFmt->yOffset);
  else
    p += sprintf(p, "Char offset:          N/A\n");
 
  if (pFmt->dwMask & CFM_CHARSET)
    p += sprintf(p, "Font charset:         %d\n", (int)pFmt->bCharSet);
  else
    p += sprintf(p, "Font charset:         N/A\n");
    
  /* I'm assuming CFM_xxx and CFE_xxx are the same values, fortunately it IS true wrt used flags*/
  ME_DumpStyleEffect(&p, "Font bold:", pFmt, CFM_BOLD);
  ME_DumpStyleEffect(&p, "Font italic:", pFmt, CFM_ITALIC);
  ME_DumpStyleEffect(&p, "Font underline:", pFmt, CFM_UNDERLINE);
  ME_DumpStyleEffect(&p, "Font strikeout:", pFmt, CFM_STRIKEOUT);
  ME_DumpStyleEffect(&p, "Hidden text:", pFmt, CFM_HIDDEN);
  p += sprintf(p, "Text color:           ");
  if (pFmt->dwMask & CFM_COLOR)
  {
    if (pFmt->dwEffects & CFE_AUTOCOLOR)
      p += sprintf(p, "auto\n");
    else
      p += sprintf(p, "%06x\n", (int)pFmt->crTextColor);
  }
  else
    p += sprintf(p, "N/A\n");
  ME_DumpStyleEffect(&p, "Text protected:", pFmt, CFM_PROTECTED);
}

Referenced by ME_DumpStyle(), and ME_KeyDown().

◆ ME_EmptyUndoStack()

void ME_EmptyUndoStack ( ME_TextEditor * editor )

Definition at line 53 of file undo.c.

{
  struct undo_item *cursor, *cursor2;
  if (editor->nUndoMode == umIgnore)
    return;
  
  TRACE("Emptying undo stack\n");
 
  editor->nUndoStackSize = 0;
 
  LIST_FOR_EACH_ENTRY_SAFE( cursor, cursor2, &editor->undo_stack, struct undo_item, entry )
  {
      list_remove( &cursor->entry );
      destroy_undo_item( cursor );
  }
 
  empty_redo_stack( editor );
}

Referenced by add_undo_insert_run(), editor_handle_message(), fnTextSrv_TxSetText(), ME_DestroyEditor(), ME_ReplaceSel(), and ME_StreamIn().

◆ ME_EndToUnicode()

void ME_EndToUnicode	(	LONG	codepage,
		LPVOID	psz
	)

Definition at line 248 of file string.c.

{
  if (codepage != CP_UNICODE)
    heap_free( psz );
}

Referenced by editor_handle_message(), ME_SetText(), and RichEditWndProc_common().

◆ ME_FindItemBack()

ME_DisplayItem * ME_FindItemBack	(	ME_DisplayItem *	di,
		ME_DIType	nTypeOrClass
	)

Definition at line 66 of file list.c.

{
  if (!di)
    return NULL;
  di = di->prev;
  while(di!=NULL) {
    if (ME_DITypesEqual(di->type, nTypeOrClass))
      return di;
    di = di->prev;
  }
  return NULL;
}

Referenced by cell_end_para(), para_end_row(), row_end_cursor(), row_from_cursor(), row_next_run(), row_prev_all_paras(), table_outer_para(), and table_row_start().

◆ ME_FindItemBackOrHere()

ME_DisplayItem * ME_FindItemBackOrHere	(	ME_DisplayItem *	di,
		ME_DIType	nTypeOrClass
	)

Definition at line 79 of file list.c.

{
  while(di!=NULL) {
    if (ME_DITypesEqual(di->type, nTypeOrClass))
      return di;
    di = di->prev;
  }
  return NULL;
}

◆ ME_FindItemFwd()

ME_DisplayItem * ME_FindItemFwd	(	ME_DisplayItem *	di,
		ME_DIType	nTypeOrClass
	)

Definition at line 89 of file list.c.

{
  if (!di) return NULL;
  di = di->next;
  while(di!=NULL) {
    if (ME_DITypesEqual(di->type, nTypeOrClass))
      return di;
    di = di->next;
  }
  return NULL;
}

Referenced by cell_first_para(), ME_CheckCharOffsets(), para_first_row(), row_end_cursor(), row_first_cursor(), row_first_run(), row_next(), row_next_all_paras(), row_next_run(), and table_row_end().

◆ ME_FindNonWhitespaceV()

int ME_FindNonWhitespaceV	(	const ME_String *	s,
		int	nVChar
	)

◆ ME_GetCharFormat()

void ME_GetCharFormat	(	ME_TextEditor *	editor,
		const ME_Cursor *	from,
		const ME_Cursor *	to,
		CHARFORMAT2W *	pFmt
	)

Definition at line 871 of file run.c.

{
  ME_Run *run, *run_end, *prev_run;
  CHARFORMAT2W tmp;
 
  run = from->run;
  /* special case - if selection is empty, take previous char's formatting */
  if (from->run == to->run && from->nOffset == to->nOffset)
  {
    if (!from->nOffset && (prev_run = run_prev( run ))) run = prev_run;
    run_copy_char_fmt( run, fmt );
    return;
  }
 
  run_end = to->run;
  if (!to->nOffset) run_end = run_prev_all_paras( run_end );
 
  run_copy_char_fmt( run, fmt );
 
  if (run == run_end) return;
 
  do {
    /* FIXME add more style feature comparisons */
    DWORD dwAttribs = CFM_SIZE | CFM_FACE | CFM_COLOR | CFM_UNDERLINETYPE;
    DWORD dwEffects = CFM_BOLD | CFM_ITALIC | CFM_UNDERLINE | CFM_STRIKEOUT | CFM_PROTECTED | CFM_LINK | CFM_SUPERSCRIPT;
 
    run = run_next_all_paras( run );
 
    memset( &tmp, 0, sizeof(tmp) );
    tmp.cbSize = sizeof(tmp);
    run_copy_char_fmt( run, &tmp );
 
    assert((tmp.dwMask & dwAttribs) == dwAttribs);
    /* reset flags that differ */
 
    if (fmt->yHeight != tmp.yHeight) fmt->dwMask &= ~CFM_SIZE;
    if (fmt->dwMask & CFM_FACE)
    {
      if (!(tmp.dwMask & CFM_FACE))
        fmt->dwMask &= ~CFM_FACE;
      else if (wcscmp( fmt->szFaceName, tmp.szFaceName ) ||
               fmt->bPitchAndFamily != tmp.bPitchAndFamily)
        fmt->dwMask &= ~CFM_FACE;
    }
    if (fmt->yHeight != tmp.yHeight) fmt->dwMask &= ~CFM_SIZE;
    if (fmt->bUnderlineType != tmp.bUnderlineType) fmt->dwMask &= ~CFM_UNDERLINETYPE;
    if (fmt->dwMask & CFM_COLOR)
    {
      if (!((fmt->dwEffects&CFE_AUTOCOLOR) & (tmp.dwEffects&CFE_AUTOCOLOR)))
      {
        if (fmt->crTextColor != tmp.crTextColor)
          fmt->dwMask &= ~CFM_COLOR;
      }
    }
 
    fmt->dwMask &= ~((fmt->dwEffects ^ tmp.dwEffects) & dwEffects);
    fmt->dwEffects = tmp.dwEffects;
 
  } while(run != run_end);
}

Referenced by get_textfont_prop_for_pos(), ME_GetSelectionCharFormat(), ME_StreamIn(), and ME_UpdateLinkAttribute().

◆ ME_GetCursorOfs()

int ME_GetCursorOfs ( const ME_Cursor * cursor )

Definition at line 889 of file caret.c.

{
    return cursor->para->nCharOfs + cursor->run->nCharOfs + cursor->nOffset;
}

Referenced by editor_copy(), editor_handle_message(), editor_set_cursor(), get_unicode_text(), handle_wm_char(), ITextSelection_fnGetText(), link_notify(), ME_ExtendAnchorSelection(), ME_FindText(), ME_GetDataObject(), ME_GetSelection(), ME_GetSelectionOfs(), ME_GetTextLength(), ME_InternalDeleteText(), ME_MoveCursorChars(), ME_RTFSpecialCharHook(), ME_StreamIn(), ME_UpdateLinkAttribute(), row_number_from_char_ofs(), table_handle_tab(), and table_protect_partial_deletion().

◆ ME_GetDataObject()

HRESULT ME_GetDataObject	(	ME_TextEditor *	editor,
		const ME_Cursor *	start,
		int	nChars,
		LPDATAOBJECT *	lplpdataobj
	)

◆ ME_GetDefaultCharFormat()

void ME_GetDefaultCharFormat	(	ME_TextEditor *	editor,
		CHARFORMAT2W *	pFmt
	)

Definition at line 842 of file run.c.

{
  ME_CopyCharFormat(pFmt, &editor->pBuffer->pDefaultStyle->fmt);
}

Referenced by editor_handle_message().

◆ ME_GetOLEObjectSize()

void ME_GetOLEObjectSize	(	const ME_Context *	c,
		ME_Run *	run,
		SIZE *	pSize
	)

Definition at line 5649 of file richole.c.

{
  IDataObject*  ido;
  FORMATETC     fmt;
  STGMEDIUM     stgm;
  DIBSECTION    dibsect;
  ENHMETAHEADER emh;
 
  assert(run->nFlags & MERF_GRAPHICS);
  assert(run->reobj);
 
  if (run->reobj->obj.sizel.cx != 0 || run->reobj->obj.sizel.cy != 0)
  {
    convert_sizel(c, &run->reobj->obj.sizel, pSize);
    if (c->editor->nZoomNumerator != 0)
    {
      pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
      pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
    }
    return;
  }
 
  if (!run->reobj->obj.poleobj)
  {
    pSize->cx = pSize->cy = 0;
    return;
  }
 
  if (IOleObject_QueryInterface(run->reobj->obj.poleobj, &IID_IDataObject, (void**)&ido) != S_OK)
  {
      FIXME("Query Interface IID_IDataObject failed!\n");
      pSize->cx = pSize->cy = 0;
      return;
  }
  fmt.cfFormat = CF_BITMAP;
  fmt.ptd = NULL;
  fmt.dwAspect = DVASPECT_CONTENT;
  fmt.lindex = -1;
  fmt.tymed = TYMED_GDI;
  if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
  {
    fmt.cfFormat = CF_ENHMETAFILE;
    fmt.tymed = TYMED_ENHMF;
    if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK)
    {
      FIXME("unsupported format\n");
      pSize->cx = pSize->cy = 0;
      IDataObject_Release(ido);
      return;
    }
  }
  IDataObject_Release(ido);
 
  switch (stgm.tymed)
  {
  case TYMED_GDI:
    GetObjectW(stgm.u.hBitmap, sizeof(dibsect), &dibsect);
    pSize->cx = dibsect.dsBm.bmWidth;
    pSize->cy = dibsect.dsBm.bmHeight;
    break;
  case TYMED_ENHMF:
    GetEnhMetaFileHeader(stgm.u.hEnhMetaFile, sizeof(emh), &emh);
    pSize->cx = emh.rclBounds.right - emh.rclBounds.left;
    pSize->cy = emh.rclBounds.bottom - emh.rclBounds.top;
    break;
  default:
    FIXME("Unsupported tymed %d\n", stgm.tymed);
    break;
  }
  ReleaseStgMedium(&stgm);
  if (c->editor->nZoomNumerator != 0)
  {
    pSize->cx = MulDiv(pSize->cx, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
    pSize->cy = MulDiv(pSize->cy, c->editor->nZoomNumerator, c->editor->nZoomDenominator);
  }
}

Referenced by ME_CharFromPointContext(), ME_GetRunSizeCommon(), and ME_PointFromCharContext().

◆ ME_GetParaBorderWidth()

int ME_GetParaBorderWidth	(	const ME_Context *	c,
		int	flags
	)

Definition at line 537 of file paint.c.

{
  int idx = (flags >> 8) & 0xF;
  int width;
 
  if (idx >= ARRAY_SIZE(border_details))
  {
      FIXME("Unsupported border value %d\n", idx);
      return 0;
  }
  width = ME_GetBorderPenWidth(c, idx);
  if (border_details[idx].dble) width = width * 2 + 1;
  return width;
}

Referenced by ME_DrawParaDecoration(), and ME_WrapTextParagraph().

◆ ME_GetRunSizeCommon()

SIZE ME_GetRunSizeCommon	(	ME_Context *	c,
		const ME_Paragraph *	para,
		ME_Run *	run,
		int	nLen,
		int	startx,
		int *	pAscent,
		int *	pDescent
	)

Definition at line 669 of file run.c.

{
  SIZE size;
 
  nLen = min( nLen, run->len );
 
  if (run->nFlags & MERF_ENDPARA)
  {
      nLen = min( nLen, 1 );
      ME_GetTextExtent( c, L" ", nLen, run->style, &size );
  }
  else if (para->nFlags & MEPF_COMPLEX)
  {
      size.cx = run->nWidth;
  }
  else if (c->editor->password_char)
  {
    ME_String *szMasked = ME_MakeStringR( c->editor->password_char, nLen );
    ME_GetTextExtent(c, szMasked->szData, nLen,run->style, &size); 
    ME_DestroyString(szMasked);
  }
  else
  {
    ME_GetTextExtent(c, get_text( run, 0 ), nLen, run->style, &size);
  }
  *pAscent = run->style->tm.tmAscent;
  *pDescent = run->style->tm.tmDescent;
  size.cy = *pAscent + *pDescent;
 
  if (run->nFlags & MERF_TAB)
  {
    int pos = 0, i = 0, ppos, shift = 0;
    const PARAFORMAT2 *pFmt = &para->fmt;
 
    if (c->editor->bEmulateVersion10 && /* v1.0 - 3.0 */
        pFmt->dwMask & PFM_TABLE && pFmt->wEffects & PFE_TABLE)
      /* The horizontal gap shifts the tab positions to leave the gap. */
      shift = pFmt->dxOffset * 2;
    do {
      if (i < pFmt->cTabCount)
      {
        /* Only one side of the horizontal gap is needed at the end of
         * the table row. */
        if (i == pFmt->cTabCount -1)
          shift = shift >> 1;
        pos = shift + (pFmt->rgxTabs[i]&0x00FFFFFF);
        i++;
      }
      else
      {
        pos += lDefaultTab - (pos % lDefaultTab);
      }
      ppos = ME_twips2pointsX(c, pos);
      if (ppos > startx + run->pt.x) {
        size.cx = ppos - startx - run->pt.x;
        break;
      }
    } while(1);
    size.cy = *pAscent + *pDescent;
    return size;
  }
  if (run->nFlags & MERF_GRAPHICS)
  {
    ME_GetOLEObjectSize(c, run, &size);
    if (size.cy > *pAscent)
      *pAscent = size.cy;
    /* descent is unchanged */
    return size;
  }
  return size;
}

Referenced by calc_run_extent().

◆ ME_GetSelection()

int ME_GetSelection	(	ME_TextEditor *	editor,
		ME_Cursor **	from,
		ME_Cursor **	to
	)

Definition at line 57 of file caret.c.

{
  int from_ofs = ME_GetCursorOfs( &editor->pCursors[0] );
  int to_ofs   = ME_GetCursorOfs( &editor->pCursors[1] );
  BOOL swap = (from_ofs > to_ofs);
 
  if (from_ofs == to_ofs)
  {
      /* If cursor[0] is at the beginning of a run and cursor[1] at the end
         of the prev run then we need to swap. */
      if (editor->pCursors[0].nOffset < editor->pCursors[1].nOffset)
          swap = TRUE;
  }
 
  if (!swap)
  {
    *from = &editor->pCursors[0];
    *to = &editor->pCursors[1];
    return 0;
  } else {
    *from = &editor->pCursors[1];
    *to = &editor->pCursors[0];
    return 1;
  }
}

Referenced by IRichEditOle_fnGetObject(), ITextSelection_fnGetChar(), ITextSelection_fnGetText(), ME_GetSelectionCharFormat(), ME_SetSelectionCharFormat(), ME_StreamIn(), ME_UpdateSelectionLinkAttribute(), and style_get_insert_style().

◆ ME_GetSelectionCharFormat()

void ME_GetSelectionCharFormat	(	ME_TextEditor *	editor,
		CHARFORMAT2W *	pFmt
	)

Definition at line 853 of file run.c.

{
  ME_Cursor *from, *to;
  if (!ME_IsSelection(editor) && editor->pBuffer->pCharStyle)
  {
    ME_CopyCharFormat(pFmt, &editor->pBuffer->pCharStyle->fmt);
    return;
  }
  ME_GetSelection(editor, &from, &to);
  ME_GetCharFormat(editor, from, to, pFmt);
}

Referenced by editor_handle_message(), ME_KeyDown(), and update_caret().

◆ ME_GetSelectionInsertStyle()

ME_Style * ME_GetSelectionInsertStyle ( ME_TextEditor * editor )

Definition at line 1415 of file caret.c.

{
    return style_get_insert_style( editor, editor->pCursors );
}

Referenced by editor_handle_message(), ME_ReplaceSel(), and ME_StreamIn().

◆ ME_GetSelectionOfs()

int ME_GetSelectionOfs	(	ME_TextEditor *	editor,
		int *	from,
		int *	to
	)

Definition at line 42 of file caret.c.

{
  *from = ME_GetCursorOfs(&editor->pCursors[0]);
  *to =   ME_GetCursorOfs(&editor->pCursors[1]);
 
  if (*from > *to)
  {
    int tmp = *from;
    *from = *to;
    *to = tmp;
    return 1;
  }
  return 0;
}

Referenced by copy_or_cut(), draw_run(), editor_handle_message(), editor_set_cursor(), handle_enter(), handle_wm_char(), IRichEditOle_fnGetClipboardData(), ITextSelection_fnCollapse(), ITextSelection_fnGetEnd(), ITextSelection_fnGetStart(), ITextSelection_fnSetEnd(), ITextSelection_fnSetStart(), ITextSelection_fnSetText(), ME_DeleteSelection(), ME_GetSelectionType(), ME_GetTextEx(), ME_InvalidateSelection(), ME_ReplaceSel(), ME_SendSelChange(), ME_ShowContextMenu(), ME_StreamIn(), ME_StreamOut(), and set_selection_cursors().

◆ ME_GetTextLength()

int ME_GetTextLength ( ME_TextEditor * editor )

Definition at line 83 of file caret.c.

{
  ME_Cursor cursor;
  ME_SetCursorToEnd(editor, &cursor, FALSE);
  return ME_GetCursorOfs(&cursor);
}

Referenced by cp2range(), cursor_from_char_ofs(), editor_handle_message(), fnTextSrv_TxGetText(), fnTextSrv_TxSetText(), handle_enter(), handle_wm_char(), ITextRange_fnGetText(), ITextSelection_fnGetText(), ME_FindText(), ME_GetTextLengthEx(), ME_InsertTextFromCursor(), ME_InternalDeleteText(), ME_InvalidateSelection(), ME_MoveCursorChars(), ME_StreamIn(), ME_StreamOut(), set_selection_cursors(), textrange_get_storylength(), textrange_setend(), and textrange_setstart().

◆ ME_GetTextLengthEx()

int ME_GetTextLengthEx	(	ME_TextEditor *	editor,
		const GETTEXTLENGTHEX *	how
	)

Definition at line 91 of file caret.c.

{
  int length;
 
  if (how->flags & GTL_PRECISE && how->flags & GTL_CLOSE)
    return E_INVALIDARG;
  if (how->flags & GTL_NUMCHARS && how->flags & GTL_NUMBYTES)
    return E_INVALIDARG;
  
  length = ME_GetTextLength(editor);
 
  if ((editor->props & TXTBIT_MULTILINE)
        && (how->flags & GTL_USECRLF)
        && !editor->bEmulateVersion10) /* Ignore GTL_USECRLF flag in 1.0 emulation */
    length += editor->nParagraphs - 1;
 
  if (how->flags & GTL_NUMBYTES ||
      (how->flags & GTL_PRECISE &&     /* GTL_PRECISE seems to imply GTL_NUMBYTES */
       !(how->flags & GTL_NUMCHARS)))  /* unless GTL_NUMCHARS is given */
  {
    CPINFO cpinfo;
    
    if (how->codepage == 1200)
      return length * 2;
    if (how->flags & GTL_PRECISE)
      FIXME("GTL_PRECISE flag unsupported. Using GTL_CLOSE\n");
    if (GetCPInfo(how->codepage, &cpinfo))
      return length * cpinfo.MaxCharSize;
    ERR("Invalid codepage %u\n", how->codepage);
    return E_INVALIDARG;
  }
  return length; 
}

Referenced by editor_handle_message().

◆ ME_GetTextW()

int ME_GetTextW	(	ME_TextEditor *	editor,
		WCHAR *	buffer,
		int	buflen,
		const ME_Cursor *	start,
		int	srcChars,
		BOOL	bCRLF,
		BOOL	bEOP
	)

Definition at line 4310 of file editor.c.

{
  ME_Run *run, *next_run;
  const WCHAR *pStart = buffer;
  const WCHAR *str;
  int nLen;
 
  /* bCRLF flag is only honored in 2.0 and up. 1.0 must always return text verbatim */
  if (editor->bEmulateVersion10) bCRLF = FALSE;
 
  run = start->run;
  next_run = run_next_all_paras( run );
 
  nLen = run->len - start->nOffset;
  str = get_text( run, start->nOffset );
 
  while (srcChars && buflen && next_run)
  {
    if (bCRLF && run->nFlags & MERF_ENDPARA && ~run->nFlags & MERF_ENDCELL)
    {
      if (buflen == 1) break;
      /* FIXME: native fails to reduce srcChars here for WM_GETTEXT or
       *        EM_GETTEXTEX, however, this is done for copying text which
       *        also uses this function. */
      srcChars -= min(nLen, srcChars);
      nLen = 2;
      str = L"\r\n";
    }
    else
    {
      nLen = min(nLen, srcChars);
      srcChars -= nLen;
    }
 
    nLen = min(nLen, buflen);
    buflen -= nLen;
 
    CopyMemory(buffer, str, sizeof(WCHAR) * nLen);
 
    buffer += nLen;
 
    run = next_run;
    next_run = run_next_all_paras( run );
 
    nLen = run->len;
    str = get_text( run, 0 );
  }
  /* append '\r' to the last paragraph. */
#ifdef __REACTOS__
  if (run == para_end_run( para_prev( editor_end_para( editor ) ) ) && bEOP && buflen)
#else
  if (run == para_end_run( para_prev( editor_end_para( editor ) ) ) && bEOP)
#endif
  {
    *buffer = '\r';
    buffer ++;
  }
  *buffer = 0;
  return buffer - pStart;
}

Referenced by fnTextSrv_TxGetText(), get_text_range(), get_unicode_text(), ITextRange_fnGetText(), ITextSelection_fnGetText(), ME_GetTextEx(), ME_IsCandidateAnURL(), ME_StreamIn(), and range_GetChar().

◆ ME_InitCharFormat2W()

void ME_InitCharFormat2W ( CHARFORMAT2W * pFmt )

Definition at line 150 of file style.c.

{
  ZeroMemory(pFmt, sizeof(CHARFORMAT2W));
  pFmt->cbSize = sizeof(CHARFORMAT2W);
}

Referenced by ME_CharFormatFromLogFont(), and para_join().

◆ ME_InitContext()

void ME_InitContext	(	ME_Context *	c,
		ME_TextEditor *	editor,
		HDC	hDC
	)

Definition at line 23 of file context.c.

{
  c->hDC = hDC;
  c->editor = editor;
  c->pt.x = 0;
  c->pt.y = 0;
  c->rcView = editor->rcFormat;
  c->current_style = NULL;
  c->orig_font = NULL;
  if (hDC) {
      c->dpi.cx = GetDeviceCaps(hDC, LOGPIXELSX);
      c->dpi.cy = GetDeviceCaps(hDC, LOGPIXELSY);
  } else {
      c->dpi.cx = c->dpi.cy = 96;
  }
  if (editor->nAvailWidth)
      c->nAvailWidth = ME_twips2pointsX(c, editor->nAvailWidth);
  else
      c->nAvailWidth = c->rcView.right - c->rcView.left;
}

Referenced by cursor_coords(), editor_draw(), ME_CharFromPoint(), ME_MakeFirstParagraph(), ME_PointFromChar(), stream_out_graphics(), and wrap_marked_paras_dc().

◆ ME_InitTableDef()

void ME_InitTableDef	(	ME_TextEditor *	editor,
		struct RTFTable *	tableDef
	)

Definition at line 556 of file table.c.

{
  ZeroMemory(tableDef->cells, sizeof(tableDef->cells));
  ZeroMemory(tableDef->border, sizeof(tableDef->border));
  tableDef->numCellsDefined = 0;
  tableDef->leftEdge = 0;
  if (!editor->bEmulateVersion10) /* v4.1 */
    tableDef->gapH = 10;
  else /* v1.0 - 3.0 */
    tableDef->gapH = 0;
}

Referenced by ME_RTFTblAttrHook().

◆ ME_InsertBefore()

void ME_InsertBefore	(	ME_DisplayItem *	diWhere,
		ME_DisplayItem *	diWhat
	)

Definition at line 26 of file list.c.

{
  diWhat->next = diWhere;
  diWhat->prev = diWhere->prev;
 
  diWhere->prev->next = diWhat;
  diWhat->next->prev = diWhat;
}

Referenced by ME_InsertRowStart(), ME_MakeFirstParagraph(), para_split(), run_insert(), and run_split().

◆ ME_InsertEndRowFromCursor()

void ME_InsertEndRowFromCursor	(	ME_TextEditor *	editor,
		int	nCursor
	)

Definition at line 537 of file caret.c.

{
  const WCHAR space = ' ';
  ME_Cursor *cursor = editor->pCursors + nCursor;
  ME_Style *style = style_get_insert_style( editor, cursor );
 
  /* FIXME no no no */
  if (ME_IsSelection(editor))
    ME_DeleteSelection(editor);
 
  run_insert( editor, cursor, style, &space, 1, MERF_ENDROW );
 
  ME_ReleaseStyle( style );
}

Referenced by handle_enter(), and SpecialChar().

◆ ME_InsertOLEFromCursor()

void ME_InsertOLEFromCursor	(	ME_TextEditor *	editor,
		const REOBJECT *	reo,
		int	nCursor
	)

Definition at line 503 of file caret.c.

{
  ME_Run *run, *prev;
  const WCHAR space = ' ';
  struct re_object *reobj_prev = NULL;
  ME_Cursor *cursor = editor->pCursors + nCursor;
  ME_Style *style = style_get_insert_style( editor, cursor );
 
  /* FIXME no no no */
  if (ME_IsSelection(editor))
    ME_DeleteSelection(editor);
 
  run = run_insert( editor, cursor, style, &space, 1, MERF_GRAPHICS );
 
  run->reobj = create_re_object( reo );
 
  prev = run;
  while ((prev = run_prev_all_paras( prev )))
  {
    if (prev->reobj)
    {
      reobj_prev = prev->reobj;
      break;
    }
  }
  if (reobj_prev)
    list_add_after(&reobj_prev->entry, &run->reobj->entry);
  else
    list_add_head(&editor->reobj_list, &run->reobj->entry);
 
  ME_ReleaseStyle( style );
}

Referenced by insert_static_object(), and IRichEditOle_fnInsertObject().

◆ ME_InsertString()

BOOL ME_InsertString	(	ME_String *	s,
		int	ofs,
		const WCHAR *	insert,
		int	len
	)

Definition at line 103 of file string.c.

{
    DWORD new_len = s->nLen + len + 1;
    WCHAR *new;
 
    assert( s->nBuffer ); /* Not a const string */
    assert( ofs <= s->nLen );
 
    if( new_len > s->nBuffer )
    {
        s->nBuffer = ME_GetOptimalBuffer( new_len );
        new = heap_realloc( s->szData, s->nBuffer * sizeof(WCHAR) );
        if (!new) return FALSE;
        s->szData = new;
    }
 
    memmove( s->szData + ofs + len, s->szData + ofs, (s->nLen - ofs + 1) * sizeof(WCHAR) );
    memcpy( s->szData + ofs, insert, len * sizeof(WCHAR) );
    s->nLen += len;
 
    return TRUE;
}

Referenced by ME_AppendString(), and run_insert().

◆ ME_InsertTextFromCursor()

void ME_InsertTextFromCursor	(	ME_TextEditor *	editor,
		int	nCursor,
		const WCHAR *	str,
		int	len,
		ME_Style *	style
	)

Definition at line 553 of file caret.c.

{
  const WCHAR *pos;
  ME_Cursor *cursor = editor->pCursors + nCursor;
  int oldLen;
 
  /* FIXME really HERE ? */
  if (ME_IsSelection(editor))
    ME_DeleteSelection(editor);
 
  oldLen = ME_GetTextLength(editor);
 
  /* text operations set modified state */
  editor->nModifyStep = 1;
 
  assert(style);
 
  if (len == -1) len = lstrlenW( str );
 
  /* grow the text limit to fit our text */
  if (editor->nTextLimit < oldLen + len) editor->nTextLimit = oldLen + len;
 
  pos = str;
 
  while (len)
  {
    /* FIXME this sucks - no respect for unicode (what else can be a line separator in unicode?) */
    while (pos - str < len && *pos != '\r' && *pos != '\n' && *pos != '\t')
      pos++;
 
    if (pos != str) /* handle text */
      run_insert( editor, cursor, style, str, pos - str, 0 );
    else if (*pos == '\t') /* handle tabs */
    {
      const WCHAR tab = '\t';
      run_insert( editor, cursor, style, &tab, 1, MERF_TAB );
      pos++;
    }
    else /* handle EOLs */
    {
      ME_Run *end_run, *run, *prev;
      ME_Paragraph *new_para;
      int eol_len = 0;
 
      /* Check if new line is allowed for this control */
      if (!(editor->props & TXTBIT_MULTILINE))
        break;
 
      /* Find number of CR and LF in end of paragraph run */
      if (*pos =='\r')
      {
        if (len > 1 && pos[1] == '\n')
          eol_len = 2;
        else if (len > 2 && pos[1] == '\r' && pos[2] == '\n')
          eol_len = 3;
        else
          eol_len = 1;
      }
      else
      {
        assert(*pos == '\n');
        eol_len = 1;
      }
      pos += eol_len;
 
      if (!editor->bEmulateVersion10 && eol_len == 3)
      {
        /* handle special \r\r\n sequence (richedit 2.x and higher only) */
        const WCHAR space = ' ';
        run_insert( editor, cursor, style, &space, 1, 0 );
      }
      else
      {
        const WCHAR cr = '\r', *eol_str = str;
 
        if (!editor->bEmulateVersion10)
        {
          eol_str = &cr;
          eol_len = 1;
        }
 
        if (cursor->nOffset == cursor->run->len)
        {
           run = run_next( cursor->run );
           if (!run) run = cursor->run;
        }
        else
        {
          if (cursor->nOffset) run_split( editor, cursor );
          run = cursor->run;
        }
 
        new_para = para_split( editor, run, style, eol_str, eol_len, 0 );
        end_run = para_end_run( para_prev( new_para ) );
 
        /* Move any cursors that were at the end of the previous run to the beginning of the new para */
        prev = run_prev( end_run );
        if (prev)
        {
          int i;
          for (i = 0; i < editor->nCursors; i++)
          {
            if (editor->pCursors[i].run == prev &&
                editor->pCursors[i].nOffset == prev->len)
            {
              editor->pCursors[i].para = new_para;
              editor->pCursors[i].run = run;
              editor->pCursors[i].nOffset = 0;
            }
          }
        }
 
      }
    }
    len -= pos - str;
    str = pos;
  }
}

Referenced by editor_handle_message(), fnTextSrv_TxSetText(), handle_enter(), handle_wm_char(), ITextRange_fnSetText(), ME_ReplaceSel(), ME_RTFParAttrHook(), ME_RTFSpecialCharHook(), ME_SetText(), ME_StreamInText(), RTFFlushUnicodeOutputBuffer(), and table_append_row().

◆ ME_InternalDeleteText()

BOOL ME_InternalDeleteText	(	ME_TextEditor *	editor,
		ME_Cursor *	start,
		int	nChars,
		BOOL	bForce
	)

Definition at line 339 of file caret.c.

{
  ME_Cursor c = *start;
  int nOfs = ME_GetCursorOfs(start), text_len = ME_GetTextLength( editor );
  int shift = 0;
  int totalChars = nChars;
  ME_Paragraph *start_para;
  BOOL delete_all = FALSE;
 
  /* Prevent deletion past last end of paragraph run. */
  nChars = min(nChars, text_len - nOfs);
  if (nChars == text_len) delete_all = TRUE;
  start_para = c.para;
 
  if (!bForce)
  {
    table_protect_partial_deletion( editor, &c, &nChars );
    if (nChars == 0) return FALSE;
  }
 
  while (nChars > 0)
  {
    ME_Run *run;
    cursor_from_char_ofs( editor, nOfs + nChars, &c );
    if (!c.nOffset)
    {
      /* We aren't deleting anything in this run, so we will go back to the
       * last run we are deleting text in. */
      c.run = run_prev_all_paras( c.run );
      c.para = c.run->para;
      c.nOffset = c.run->len;
    }
    run = c.run;
    if (run->nFlags & MERF_ENDPARA)
    {
      int eollen = c.run->len;
      BOOL keepFirstParaFormat;
 
      if (!para_next( para_next( c.para ) )) return TRUE;
 
      keepFirstParaFormat = (totalChars == nChars && nChars <= eollen &&
                             run->nCharOfs);
      if (!editor->bEmulateVersion10) /* v4.1 */
      {
        ME_Paragraph *this_para = run->para;
        ME_Paragraph *next_para = para_next( this_para );
 
        /* The end of paragraph before a table row is only deleted if there
         * is nothing else on the line before it. */
        if (this_para == start_para && next_para->nFlags & MEPF_ROWSTART)
        {
          /* If the paragraph will be empty, then it should be deleted, however
           * it still might have text right now which would inherit the
           * MEPF_STARTROW property if we joined it right now.
           * Instead we will delete it after the preceding text is deleted. */
          if (nOfs > this_para->nCharOfs)
          {
            /* Skip this end of line. */
            nChars -= (eollen < nChars) ? eollen : nChars;
            continue;
          }
          keepFirstParaFormat = TRUE;
        }
      }
      para_join( editor, c.para, keepFirstParaFormat );
      /* ME_SkipAndPropagateCharOffset(p->pRun, shift); */
      ME_CheckCharOffsets(editor);
      nChars -= (eollen < nChars) ? eollen : nChars;
      continue;
    }
    else
    {
      ME_Cursor cursor;
      int nCharsToDelete = min(nChars, c.nOffset);
      int i;
 
      c.nOffset -= nCharsToDelete;
 
      para_mark_rewrap( editor, c.run->para );
 
      cursor = c;
      /* nChars is the number of characters that should be deleted from the
         PRECEDING runs (these BEFORE cursor.pRun)
         nCharsToDelete is a number of chars to delete from THIS run */
      nChars -= nCharsToDelete;
      shift -= nCharsToDelete;
      TRACE("Deleting %d (remaining %d) chars at %d in %s (%d)\n",
        nCharsToDelete, nChars, c.nOffset,
        debugstr_run( run ), run->len);
 
      /* nOfs is a character offset (from the start of the document
         to the current (deleted) run */
      add_undo_insert_run( editor, nOfs + nChars, get_text( run, c.nOffset ), nCharsToDelete, run->nFlags, run->style );
 
      ME_StrDeleteV(run->para->text, run->nCharOfs + c.nOffset, nCharsToDelete);
      run->len -= nCharsToDelete;
      TRACE("Post deletion string: %s (%d)\n", debugstr_run( run ), run->len);
      TRACE("Shift value: %d\n", shift);
 
      /* update cursors (including c) */
      for (i=-1; i<editor->nCursors; i++) {
        ME_Cursor *pThisCur = editor->pCursors + i;
        if (i == -1) pThisCur = &c;
        if (pThisCur->run == cursor.run) {
          if (pThisCur->nOffset > cursor.nOffset) {
            if (pThisCur->nOffset-cursor.nOffset < nCharsToDelete)
              pThisCur->nOffset = cursor.nOffset;
            else
              pThisCur->nOffset -= nCharsToDelete;
            assert(pThisCur->nOffset >= 0);
            assert(pThisCur->nOffset <= run->len);
          }
          if (pThisCur->nOffset == run->len)
          {
            pThisCur->run = run_next( pThisCur->run );
            assert( pThisCur->run );
            pThisCur->nOffset = 0;
          }
        }
      }
 
      /* c = updated data now */
 
      if (c.run == cursor.run) c.run->nCharOfs -= shift;
      editor_propagate_char_ofs( NULL, c.run, shift );
 
      if (!cursor.run->len)
      {
        TRACE("Removing empty run\n");
        ME_Remove( run_get_di( cursor.run ));
        ME_DestroyDisplayItem( run_get_di( cursor.run ));
      }
 
      shift = 0;
      continue;
    }
  }
  if (delete_all) editor_set_default_para_fmt( editor, &start_para->fmt );
  return TRUE;
}

Referenced by editor_copy_or_cut(), editor_handle_message(), fnTextSrv_TxSetText(), ITextRange_fnSetText(), ME_DeleteTextAtCursor(), ME_PlayUndoItem(), ME_ReplaceSel(), ME_RTFSpecialCharHook(), and ME_StreamIn().

◆ ME_InvalidateSelection()

void ME_InvalidateSelection ( ME_TextEditor * editor )

Definition at line 1247 of file paint.c.

{
  ME_Paragraph *sel_start, *sel_end;
  ME_Paragraph *repaint_start = NULL, *repaint_end = NULL;
  int nStart, nEnd;
  int len = ME_GetTextLength(editor);
 
  ME_GetSelectionOfs(editor, &nStart, &nEnd);
  /* if both old and new selection are 0-char (= caret only), then
  there's no (inverted) area to be repainted, neither old nor new */
  if (nStart == nEnd && editor->nLastSelStart == editor->nLastSelEnd)
    return;
  ME_WrapMarkedParagraphs(editor);
  editor_get_selection_paras( editor, &sel_start, &sel_end );
 
  /* last selection markers aren't always updated, which means
   * they can point past the end of the document */
  if (editor->nLastSelStart > len || editor->nLastSelEnd > len)
  {
    repaint_start = editor_first_para( editor );
    repaint_end = para_prev( editor_end_para( editor ) );
  }
  else
  {
    /* if the start part of selection is being expanded or contracted... */
    if (nStart < editor->nLastSelStart)
    {
      repaint_start = sel_start;
      repaint_end = editor->last_sel_start_para;
    }
    else if (nStart > editor->nLastSelStart)
    {
      repaint_start = editor->last_sel_start_para;
      repaint_end = sel_start;
    }
 
    /* if the end part of selection is being contracted or expanded... */
    if (nEnd < editor->nLastSelEnd)
    {
      if (!repaint_start) repaint_start = sel_end;
      repaint_end = editor->last_sel_end_para;
    }
    else if (nEnd > editor->nLastSelEnd)
    {
      if (!repaint_start) repaint_start = editor->last_sel_end_para;
      repaint_end = sel_end;
    }
  }
 
  if (repaint_start)
    para_range_invalidate( editor, repaint_start, repaint_end );
  /* remember the last invalidated position */
  ME_GetSelectionOfs(editor, &editor->nLastSelStart, &editor->nLastSelEnd);
  editor_get_selection_paras( editor, &editor->last_sel_start_para, &editor->last_sel_end_para );
}

Referenced by editor_handle_message(), fnTextSrv_OnTxPropertyBitsChange(), ME_ArrowKey(), ME_LButtonDown(), ME_MouseMove(), set_selection(), and table_handle_tab().

◆ ME_IsSelection()

BOOL ME_IsSelection ( ME_TextEditor * editor )

Definition at line 1400 of file caret.c.

{
  return editor->pCursors[0].run != editor->pCursors[1].run ||
         editor->pCursors[0].nOffset != editor->pCursors[1].nOffset;
}

Referenced by editor_set_cursor(), handle_EM_SETCHARFORMAT(), handle_wm_char(), ME_GetSelectionCharFormat(), ME_InsertEndRowFromCursor(), ME_InsertOLEFromCursor(), ME_InsertTextFromCursor(), ME_KeyDown(), ME_LButtonDown(), ME_SetSelectionCharFormat(), style_get_insert_style(), table_handle_tab(), and update_caret().

◆ ME_IsWSpace()

static int ME_IsWSpace ( WCHAR ch )

inlinestatic

Definition at line 99 of file editor.h.

{
  return ch > '\0' && ch <= ' ';
}

Referenced by find_non_whitespace(), ME_UpdateRunFlags(), ME_WordBreakProc(), reverse_find_non_whitespace(), reverse_find_whitespace(), run_is_entirely_ws(), and run_is_splittable().

◆ ME_LButtonDown()

void ME_LButtonDown	(	ME_TextEditor *	editor,
		int	x,
		int	y,
		int	clickNum
	)

Definition at line 1137 of file caret.c.

{
  ME_Cursor tmp_cursor;
  BOOL is_selection = FALSE, is_shift;
 
  editor->nUDArrowX = -1;
 
  x += editor->horz_si.nPos;
  y += editor->vert_si.nPos;
 
  tmp_cursor = editor->pCursors[0];
  is_selection = ME_IsSelection(editor);
  is_shift = GetKeyState(VK_SHIFT) < 0;
 
  cursor_from_virtual_coords( editor, x, y, &editor->pCursors[0], FALSE );
 
  if (x >= editor->rcFormat.left || is_shift)
  {
    if (clickNum > 1)
    {
      editor->pCursors[1] = editor->pCursors[0];
      if (is_shift) {
          if (x >= editor->rcFormat.left)
              ME_SelectByType(editor, stWord);
          else
              ME_SelectByType(editor, stParagraph);
      } else if (clickNum % 2 == 0) {
          ME_SelectByType(editor, stWord);
      } else {
          ME_SelectByType(editor, stParagraph);
      }
    }
    else if (!is_shift)
    {
      editor->nSelectionType = stPosition;
      editor->pCursors[1] = editor->pCursors[0];
    }
    else if (!is_selection)
    {
      editor->nSelectionType = stPosition;
      editor->pCursors[1] = tmp_cursor;
    }
    else if (editor->nSelectionType != stPosition)
    {
      ME_ExtendAnchorSelection(editor);
    }
  }
  else
  {
    if (clickNum < 2) {
        ME_SelectByType(editor, stLine);
    } else if (clickNum % 2 == 0 || is_shift) {
        ME_SelectByType(editor, stParagraph);
    } else {
        ME_SelectByType(editor, stDocument);
    }
  }
  ME_InvalidateSelection(editor);
  update_caret(editor);
  ME_SendSelChange(editor);
}

Referenced by editor_handle_message().

◆ ME_MakeDI()

ME_DisplayItem * ME_MakeDI ( ME_DIType type )

Definition at line 133 of file list.c.

{
  ME_DisplayItem *item = heap_alloc_zero(sizeof(*item));
 
  item->type = type;
  item->prev = item->next = NULL;
  return item;
}

Referenced by cell_create(), ME_MakeText(), para_create(), row_create(), and run_create().

◆ ME_MakeEditor()

ME_TextEditor * ME_MakeEditor	(	ITextHost *	texthost,
		BOOL	bEmulateVersion10
	)

Definition at line 2933 of file editor.c.

{
  ME_TextEditor *ed = heap_alloc(sizeof(*ed));
  int i;
  LONG selbarwidth;
  HRESULT hr;
 
  ed->sizeWindow.cx = ed->sizeWindow.cy = 0;
  if (ITextHost_QueryInterface( texthost, &IID_ITextHost2, (void **)&ed->texthost ) == S_OK)
  {
    ITextHost_Release( texthost );
    ed->have_texthost2 = TRUE;
  }
  else
  {
    ed->texthost = (ITextHost2 *)texthost;
    ed->have_texthost2 = FALSE;
  }
 
  ed->bEmulateVersion10 = bEmulateVersion10;
  ed->in_place_active = FALSE;
  ed->total_rows = 0;
  ITextHost_TxGetPropertyBits( ed->texthost, TXTBIT_RICHTEXT | TXTBIT_MULTILINE | TXTBIT_READONLY |
                               TXTBIT_USEPASSWORD | TXTBIT_HIDESELECTION | TXTBIT_SAVESELECTION |
                               TXTBIT_AUTOWORDSEL | TXTBIT_VERTICAL | TXTBIT_WORDWRAP | TXTBIT_ALLOWBEEP |
                               TXTBIT_DISABLEDRAG,
                               &ed->props );
  ITextHost_TxGetScrollBars( ed->texthost, &ed->scrollbars );
  ed->pBuffer = ME_MakeText();
  ed->nZoomNumerator = ed->nZoomDenominator = 0;
  ed->nAvailWidth = 0; /* wrap to client area */
  list_init( &ed->style_list );
  ME_MakeFirstParagraph(ed);
  /* The four cursors are for:
   * 0 - The position where the caret is shown
   * 1 - The anchored end of the selection (for normal selection)
   * 2 & 3 - The anchored start and end respectively for word, line,
   * or paragraph selection.
   */
  ed->nCursors = 4;
  ed->pCursors = heap_alloc(ed->nCursors * sizeof(*ed->pCursors));
  ME_SetCursorToStart(ed, &ed->pCursors[0]);
  ed->pCursors[1] = ed->pCursors[0];
  ed->pCursors[2] = ed->pCursors[0];
  ed->pCursors[3] = ed->pCursors[1];
  ed->nLastTotalLength = ed->nTotalLength = 0;
  ed->nLastTotalWidth = ed->nTotalWidth = 0;
  ed->nUDArrowX = -1;
  ed->nEventMask = 0;
  ed->nModifyStep = 0;
  ed->nTextLimit = TEXT_LIMIT_DEFAULT;
  list_init( &ed->undo_stack );
  list_init( &ed->redo_stack );
  ed->nUndoStackSize = 0;
  ed->nUndoLimit = STACK_SIZE_DEFAULT;
  ed->nUndoMode = umAddToUndo;
  ed->nParagraphs = 1;
  ed->nLastSelStart = ed->nLastSelEnd = 0;
  ed->last_sel_start_para = ed->last_sel_end_para = ed->pCursors[0].para;
  ed->bHideSelection = FALSE;
  ed->pfnWordBreak = NULL;
  ed->richole = NULL;
  ed->lpOleCallback = NULL;
  ed->mode = TM_MULTILEVELUNDO | TM_MULTICODEPAGE;
  ed->mode |= (ed->props & TXTBIT_RICHTEXT) ? TM_RICHTEXT : TM_PLAINTEXT;
  ed->AutoURLDetect_bEnable = FALSE;
  ed->bHaveFocus = FALSE;
  ed->bMouseCaptured = FALSE;
  ed->caret_hidden = FALSE;
  ed->caret_height = 0;
  for (i=0; i<HFONT_CACHE_SIZE; i++)
  {
    ed->pFontCache[i].nRefs = 0;
    ed->pFontCache[i].nAge = 0;
    ed->pFontCache[i].hFont = NULL;
  }
 
  ME_CheckCharOffsets(ed);
  SetRectEmpty(&ed->rcFormat);
  hr = ITextHost_TxGetSelectionBarWidth( ed->texthost, &selbarwidth );
  /* FIXME: Convert selbarwidth from HIMETRIC to pixels */
  if (hr == S_OK && selbarwidth) ed->selofs = SELECTIONBAR_WIDTH;
  else ed->selofs = 0;
  ed->nSelectionType = stPosition;
 
  ed->password_char = 0;
  if (ed->props & TXTBIT_USEPASSWORD)
    ITextHost_TxGetPasswordChar( ed->texthost, &ed->password_char );
 
  ed->bWordWrap = (ed->props & TXTBIT_WORDWRAP) && (ed->props & TXTBIT_MULTILINE);
 
  ed->notified_cr.cpMin = ed->notified_cr.cpMax = 0;
 
  /* Default scrollbar information */
  ed->vert_si.cbSize = sizeof(SCROLLINFO);
  ed->vert_si.nMin = 0;
  ed->vert_si.nMax = 0;
  ed->vert_si.nPage = 0;
  ed->vert_si.nPos = 0;
  ed->vert_sb_enabled = 0;
 
  ed->horz_si.cbSize = sizeof(SCROLLINFO);
  ed->horz_si.nMin = 0;
  ed->horz_si.nMax = 0;
  ed->horz_si.nPage = 0;
  ed->horz_si.nPos = 0;
  ed->horz_sb_enabled = 0;
 
  if (ed->scrollbars & ES_DISABLENOSCROLL)
  {
      if (ed->scrollbars & WS_VSCROLL)
      {
          ITextHost_TxSetScrollRange( ed->texthost, SB_VERT, 0, 1, TRUE );
          ITextHost_TxEnableScrollBar( ed->texthost, SB_VERT, ESB_DISABLE_BOTH );
      }
      if (ed->scrollbars & WS_HSCROLL)
      {
          ITextHost_TxSetScrollRange( ed->texthost, SB_HORZ, 0, 1, TRUE );
          ITextHost_TxEnableScrollBar( ed->texthost, SB_HORZ, ESB_DISABLE_BOTH );
      }
  }
 
  ed->wheel_remain = 0;
 
  ed->back_style = TXTBACK_OPAQUE;
  ITextHost_TxGetBackStyle( ed->texthost, &ed->back_style );
 
  list_init( &ed->reobj_list );
  OleInitialize(NULL);
 
  return ed;
}

Referenced by create_text_services().

◆ ME_MakeFirstParagraph()

void ME_MakeFirstParagraph ( ME_TextEditor * editor )

Definition at line 151 of file para.c.

{
  ME_Context c;
  CHARFORMAT2W cf;
  const CHARFORMATW *host_cf;
  LOGFONTW lf;
  HFONT hf;
  ME_TextBuffer *text = editor->pBuffer;
  ME_Paragraph *para = para_create( editor );
  ME_Run *run;
  ME_Style *style;
  int eol_len;
  HDC hdc = ITextHost_TxGetDC( editor->texthost );
 
  ME_InitContext( &c, editor, hdc );
 
  hf = GetStockObject(SYSTEM_FONT);
  assert(hf);
  GetObjectW(hf, sizeof(LOGFONTW), &lf);
  ZeroMemory(&cf, sizeof(cf));
  cf.cbSize = sizeof(cf);
  cf.dwMask = CFM_ANIMATION|CFM_BACKCOLOR|CFM_CHARSET|CFM_COLOR|CFM_FACE|CFM_KERNING|CFM_LCID|CFM_OFFSET;
  cf.dwMask |= CFM_REVAUTHOR|CFM_SIZE|CFM_SPACING|CFM_STYLE|CFM_UNDERLINETYPE|CFM_WEIGHT;
  cf.dwMask |= CFM_ALLCAPS|CFM_BOLD|CFM_DISABLED|CFM_EMBOSS|CFM_HIDDEN;
  cf.dwMask |= CFM_IMPRINT|CFM_ITALIC|CFM_LINK|CFM_OUTLINE|CFM_PROTECTED;
  cf.dwMask |= CFM_REVISED|CFM_SHADOW|CFM_SMALLCAPS|CFM_STRIKEOUT;
  cf.dwMask |= CFM_SUBSCRIPT|CFM_UNDERLINE;
  
  cf.dwEffects = CFE_AUTOCOLOR | CFE_AUTOBACKCOLOR;
  lstrcpyW(cf.szFaceName, lf.lfFaceName);
  /* Convert system font height from logical units to twips for cf.yHeight */
  cf.yHeight = (lf.lfHeight * 72 * 1440) / (c.dpi.cy * c.dpi.cy);
  if (lf.lfWeight > FW_NORMAL) cf.dwEffects |= CFE_BOLD;
  cf.wWeight = lf.lfWeight;
  if (lf.lfItalic) cf.dwEffects |= CFE_ITALIC;
  if (lf.lfUnderline) cf.dwEffects |= CFE_UNDERLINE;
  cf.bUnderlineType = CFU_UNDERLINE;
  if (lf.lfStrikeOut) cf.dwEffects |= CFE_STRIKEOUT;
  cf.bPitchAndFamily = lf.lfPitchAndFamily;
  cf.bCharSet = lf.lfCharSet;
  cf.lcid = GetSystemDefaultLCID();
 
  style = ME_MakeStyle(&cf);
  text->pDefaultStyle = style;
 
  if (ITextHost_TxGetCharFormat(editor->texthost, &host_cf) == S_OK)
  {
    ZeroMemory(&cf, sizeof(cf));
    cf.cbSize = sizeof(cf);
    cfany_to_cf2w(&cf, (CHARFORMAT2W *)host_cf);
    ME_SetDefaultCharFormat(editor, &cf);
  }
 
  eol_len = editor->bEmulateVersion10 ? 2 : 1;
  para->text = ME_MakeStringN( L"\r\n", eol_len );
 
  run = run_create( style, MERF_ENDPARA );
  run->nCharOfs = 0;
  run->len = eol_len;
  run->para = para;
  para->eop_run = run;
 
  ME_InsertBefore( text->pLast, para_get_di( para) );
  ME_InsertBefore( text->pLast, run_get_di( run ) );
  para->prev_para = text->pFirst;
  para->next_para = text->pLast;
  text->pFirst->member.para.next_para = para_get_di( para );
  text->pLast->member.para.prev_para = para_get_di( para );
 
  text->pLast->member.para.nCharOfs = editor->bEmulateVersion10 ? 2 : 1;
 
  wine_rb_init( &editor->marked_paras, para_mark_compare );
  para_mark_add( editor, para );
  ME_DestroyContext(&c);
  ITextHost_TxReleaseDC( editor->texthost, hdc );
}

Referenced by ME_MakeEditor().

◆ ME_MakeStringConst()

ME_String * ME_MakeStringConst	(	const WCHAR *	str,
		int	len
	)

Definition at line 41 of file string.c.

{
  ME_String *s = make_string( NULL );
  if (!s) return NULL;
 
  s->szData = (WCHAR *)str;
  s->nLen = len;
  s->nBuffer = 0;
  return s;
}

Referenced by para_num_init().

◆ ME_MakeStringEmpty()

ME_String * ME_MakeStringEmpty ( int len )

Definition at line 58 of file string.c.

{
  ME_String *s = make_string( heap_string_free );
 
  if (!s) return NULL;
  s->nLen = nMaxChars;
  s->nBuffer = ME_GetOptimalBuffer(s->nLen + 1);
  s->szData = heap_alloc( s->nBuffer * sizeof(WCHAR) );
  if (!s->szData)
  {
    heap_free( s );
    return NULL;
  }
  s->szData[s->nLen] = 0;
  return s;
}

Referenced by ME_MakeStringN(), ME_MakeStringR(), and para_num_get_str().

◆ ME_MakeStringN()

ME_String * ME_MakeStringN	(	LPCWSTR	szText,
		int	nMaxChars
	)

Definition at line 75 of file string.c.

{
  ME_String *s = ME_MakeStringEmpty(nMaxChars);
 
  if (!s) return NULL;
  memcpy(s->szData, szText, s->nLen * sizeof(WCHAR));
  return s;
}

Referenced by ME_MakeFirstParagraph(), and ME_VSplitString().

◆ ME_MakeStringR()

ME_String * ME_MakeStringR	(	WCHAR	cRepeat,
		int	nMaxChars
	)

Definition at line 85 of file string.c.

{
  int i;
  ME_String *s = ME_MakeStringEmpty(nMaxChars);
 
  if (!s) return NULL;
  for (i = 0; i < nMaxChars; i++)
    s->szData[i] = cRepeat;
  return s;
}

Referenced by draw_text(), ME_CharFromPointContext(), ME_GetRunSizeCommon(), and ME_PointFromCharContext().

◆ ME_MakeStyle()

ME_Style * ME_MakeStyle ( CHARFORMAT2W * style )

Definition at line 121 of file style.c.

{
  ME_Style *s = heap_alloc(sizeof(*s));
 
  assert(style->cbSize == sizeof(CHARFORMAT2W));
  s->fmt = *style;
  s->nRefs = 1;
  s->font_cache = NULL;
  memset(&s->tm, 0, sizeof(s->tm));
  s->tm.tmAscent = -1;
  s->script_cache = NULL;
  list_init(&s->entry);
  all_refs++;
  TRACE_(richedit_style)("ME_MakeStyle %p, total refs=%d\n", s, all_refs);
  return s;
}

Referenced by ME_ApplyStyle(), and ME_MakeFirstParagraph().

◆ ME_MakeTableDef()

struct RTFTable * ME_MakeTableDef ( ME_TextEditor * editor )

Definition at line 547 of file table.c.

{
  RTFTable *tableDef = heap_alloc_zero(sizeof(*tableDef));
 
  if (!editor->bEmulateVersion10) /* v4.1 */
    tableDef->gapH = 10;
  return tableDef;
}

Referenced by ME_RTFTblAttrHook().

◆ ME_MouseMove()

void ME_MouseMove	(	ME_TextEditor *	editor,
		int	x,
		int	y
	)

Definition at line 1199 of file caret.c.

{
  ME_Cursor tmp_cursor;
 
  if (editor->nSelectionType == stDocument)
      return;
  x += editor->horz_si.nPos;
  y += editor->vert_si.nPos;
 
  tmp_cursor = editor->pCursors[0];
  /* FIXME: do something with the return value of cursor_from_virtual_coords */
  cursor_from_virtual_coords( editor, x, y, &tmp_cursor, TRUE );
 
  ME_InvalidateSelection(editor);
  editor->pCursors[0] = tmp_cursor;
  ME_ExtendAnchorSelection(editor);
 
  if (editor->nSelectionType != stPosition &&
      memcmp(&editor->pCursors[1], &editor->pCursors[3], sizeof(ME_Cursor)))
      /* The scroll the cursor towards the other end, since it was the one
       * extended by ME_ExtendAnchorSelection */
      editor_ensure_visible( editor, &editor->pCursors[1] );
  else
      editor_ensure_visible( editor, &editor->pCursors[0] );
 
  ME_InvalidateSelection(editor);
  update_caret(editor);
  ME_SendSelChange(editor);
}

Referenced by editor_handle_message().

◆ ME_MoveCursorChars()

int ME_MoveCursorChars	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor,
		int	nRelOfs,
		BOOL	final_eop
	)

Definition at line 678 of file caret.c.

{
  cursor->nOffset += nRelOfs;
  if (cursor->nOffset < 0)
  {
    cursor->nOffset += cursor->run->nCharOfs;
    if (cursor->nOffset >= 0)
    {
      /* new offset in the same paragraph */
      do {
        cursor->run = run_prev( cursor->run );
      } while (cursor->nOffset < cursor->run->nCharOfs);
      cursor->nOffset -= cursor->run->nCharOfs;
      return nRelOfs;
    }
 
    cursor->nOffset += cursor->para->nCharOfs;
    if (cursor->nOffset <= 0)
    {
      /* moved to the start of the text */
      nRelOfs -= cursor->nOffset;
      ME_SetCursorToStart(editor, cursor);
      return nRelOfs;
    }
 
    /* new offset in a previous paragraph */
    do {
      cursor->para = para_prev( cursor->para );
    } while (cursor->nOffset < cursor->para->nCharOfs);
    cursor->nOffset -= cursor->para->nCharOfs;
 
    cursor->run = para_end_run( cursor->para );
    while (cursor->nOffset < cursor->run->nCharOfs)
      cursor->run = run_prev( cursor->run );
    cursor->nOffset -= cursor->run->nCharOfs;
  }
  else if (cursor->nOffset >= cursor->run->len)
  {
    ME_Paragraph *next_para;
    int new_offset;
 
    new_offset = ME_GetCursorOfs(cursor);
    next_para = para_next( cursor->para );
    if (new_offset < next_para->nCharOfs)
    {
      /* new offset in the same paragraph */
      do {
        cursor->nOffset -= cursor->run->len;
        cursor->run = run_next( cursor->run );
      } while (cursor->nOffset >= cursor->run->len);
      return nRelOfs;
    }
 
    if (new_offset >= ME_GetTextLength(editor) + (final_eop ? 1 : 0))
    {
      /* new offset at the end of the text */
      ME_SetCursorToEnd(editor, cursor, final_eop);
      nRelOfs -= new_offset - (ME_GetTextLength(editor) + (final_eop ? 1 : 0));
      return nRelOfs;
    }
 
    /* new offset in a following paragraph */
    do {
      cursor->para = next_para;
      next_para = para_next( next_para );
    } while (new_offset >= next_para->nCharOfs);
 
    cursor->nOffset = new_offset - cursor->para->nCharOfs;
    cursor->run = para_first_run( cursor->para );
    while (cursor->nOffset >= cursor->run->len)
    {
      cursor->nOffset -= cursor->run->len;
      cursor->run = run_next( cursor->run );
    }
  } /* else new offset is in the same run */
  return nRelOfs;
}

Referenced by get_textfont_prop_for_pos(), ME_ArrowKey(), ME_FindText(), ME_PlayUndoItem(), ME_StreamIn(), ME_StreamOutRTF(), set_selection_cursors(), table_protect_partial_deletion(), textrange_endof(), textrange_move(), textrange_moveend(), and textrange_movestart().

◆ ME_MoveCursorWords()

BOOL ME_MoveCursorWords	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor,
		int	nRelOfs
	)

Definition at line 758 of file caret.c.

{
  ME_Run *run = cursor->run, *other_run;
  ME_Paragraph *para = cursor->para;
  int nOffset = cursor->nOffset;
 
  if (nRelOfs == -1)
  {
    /* Backward movement */
    while (TRUE)
    {
      nOffset = ME_CallWordBreakProc( editor, get_text( run, 0 ), run->len, nOffset, WB_MOVEWORDLEFT );
      if (nOffset) break;
      other_run = run_prev( run );
      if (other_run)
      {
        if (ME_CallWordBreakProc( editor, get_text( other_run, 0 ), other_run->len, other_run->len - 1, WB_ISDELIMITER )
            && !(run->nFlags & MERF_ENDPARA)
            && !(cursor->run == run && cursor->nOffset == 0)
            && !ME_CallWordBreakProc( editor, get_text( run, 0 ), run->len, 0, WB_ISDELIMITER ))
          break;
        run = other_run;
        nOffset = other_run->len;
      }
      else
      {
        if (cursor->run == run && cursor->nOffset == 0)
        {
          para = run->para;
          /* Skip empty start of table row paragraph */
          if (para_prev( para ) && para_prev( para )->nFlags & MEPF_ROWSTART)
            para = para_prev( para );
          /* Paragraph breaks are treated as separate words */
          if (!para_prev( para )) return FALSE;
          para = para_prev( para );
          run = para_end_run( para );
        }
        break;
      }
    }
  }
  else
  {
    /* Forward movement */
    BOOL last_delim = FALSE;
    
    while (TRUE)
    {
      if (last_delim && !ME_CallWordBreakProc( editor, get_text( run, 0 ), run->len, nOffset, WB_ISDELIMITER ))
        break;
      nOffset = ME_CallWordBreakProc( editor, get_text( run, 0 ), run->len, nOffset, WB_MOVEWORDRIGHT );
      if (nOffset < run->len) break;
      other_run = run_next( run );
      if (other_run)
      {
        last_delim = ME_CallWordBreakProc( editor, get_text( run, 0 ), run->len, nOffset - 1, WB_ISDELIMITER );
        run = other_run;
        nOffset = 0;
      }
      else
      {
        para = para_next( para );
        if (!para_next( para ))
        {
          if (cursor->run == run) return FALSE;
          nOffset = 0;
          break;
        }
        if (para->nFlags & MEPF_ROWSTART) para = para_next( para );
        if (cursor->run == run) run = para_first_run( para );
        nOffset = 0;
        break;
      }
    }
  }
  cursor->para = para;
  cursor->run = run;
  cursor->nOffset = nOffset;
  return TRUE;
}

Referenced by handle_EM_SETCHARFORMAT(), ME_ArrowKey(), ME_ExtendAnchorSelection(), and ME_SelectByType().

◆ ME_PointFromChar()

int ME_PointFromChar	(	ME_TextEditor *	editor,
		ME_Run *	pRun,
		int	nOffset,
		BOOL	visual_order
	)

Definition at line 649 of file run.c.

{
    ME_Context c;
    int ret;
    HDC hdc = ITextHost_TxGetDC( editor->texthost );
 
    ME_InitContext( &c, editor, hdc );
    ret = ME_PointFromCharContext( &c, pRun, nOffset, visual_order );
    ME_DestroyContext(&c);
    ITextHost_TxReleaseDC( editor->texthost, hdc );
 
    return ret;
}

Referenced by editor_ensure_visible(), editor_handle_message(), and ME_GetXForArrow().

◆ ME_PointFromCharContext()

int ME_PointFromCharContext	(	ME_Context *	c,
		ME_Run *	pRun,
		int	nOffset,
		BOOL	visual_order
	)

Definition at line 608 of file run.c.

{
  SIZE size;
  ME_String *mask_text = NULL;
  WCHAR *str;
 
  if (pRun->nFlags & MERF_GRAPHICS)
  {
    if (nOffset)
      ME_GetOLEObjectSize(c, pRun, &size);
    return nOffset != 0;
  } else if (pRun->nFlags & MERF_ENDPARA) {
    nOffset = 0;
  }
 
  if (pRun->para->nFlags & MEPF_COMPLEX)
  {
      int x;
      ScriptCPtoX( nOffset, FALSE, pRun->len, pRun->num_glyphs, pRun->clusters,
                   pRun->vis_attrs, pRun->advances, &pRun->script_analysis, &x );
      if (visual_order && pRun->script_analysis.fRTL) x = pRun->nWidth - x - 1;
      return x;
  }
  if (c->editor->password_char)
  {
    mask_text = ME_MakeStringR( c->editor->password_char, pRun->len );
    str = mask_text->szData;
  }
  else
      str = get_text( pRun, 0 );
 
  ME_GetTextExtent(c, str, nOffset, pRun->style, &size);
  ME_DestroyString( mask_text );
  return size.cx;
}

Referenced by cursor_coords(), get_selection_rect(), ME_InsertRowStart(), and ME_PointFromChar().

◆ ME_Redo()

BOOL ME_Redo ( ME_TextEditor * editor )

Definition at line 448 of file undo.c.

{
  ME_UndoMode nMode = editor->nUndoMode;
  struct list *head;
  struct undo_item *undo, *cursor2;
 
  assert(nMode == umAddToUndo || nMode == umIgnore);
  
  if (editor->nUndoMode == umIgnore) return FALSE;
 
  head = list_head( &editor->redo_stack );
  if (!head) return FALSE;
 
  /* watch out for uncommitted transactions ! */
  undo = LIST_ENTRY( head, struct undo_item, entry );
  assert( undo->type == undo_end_transaction );
 
  editor->nUndoMode = umAddBackToUndo;
  list_remove( &undo->entry );
  destroy_undo_item( undo );
 
  LIST_FOR_EACH_ENTRY_SAFE( undo, cursor2, &editor->redo_stack, struct undo_item, entry )
  {
      if (undo->type == undo_end_transaction) break;
      ME_PlayUndoItem( editor, undo );
      list_remove( &undo->entry );
      destroy_undo_item( undo );
  }
  table_move_from_row_start( editor );
  add_undo( editor, undo_end_transaction );
  editor->nUndoMode = nMode;
  ME_UpdateRepaint(editor, FALSE);
  return TRUE;
}

Referenced by editor_handle_message(), and ME_KeyDown().

◆ ME_ReleaseStyle()

void ME_ReleaseStyle ( ME_Style * item )

Definition at line 462 of file style.c.

{
  s->nRefs--;
  all_refs--;
  if (s->nRefs==0)
    TRACE_(richedit_style)("destroy style %p, total refs=%d\n", s, all_refs);
  else
    TRACE_(richedit_style)("release style %p, new refs=%d, total refs=%d\n", s, s->nRefs, all_refs);
  if (!all_refs) TRACE("all style references freed (good!)\n");
  assert(s->nRefs>=0);
  if (!s->nRefs)
    ME_DestroyStyle(s);
}

Referenced by destroy_undo_item(), editor_handle_message(), handle_enter(), handle_wm_char(), ITextRange_fnSetText(), ME_ClearTempStyle(), ME_DestroyDisplayItem(), ME_DestroyEditor(), ME_InsertEndRowFromCursor(), ME_InsertOLEFromCursor(), ME_ReplaceSel(), ME_RTFCharAttrHook(), ME_RTFReadHook(), ME_SaveTempStyle(), ME_SetCharFormat(), ME_SetDefaultCharFormat(), ME_SetSelectionCharFormat(), ME_StreamIn(), para_num_clear(), and table_insert_end_para().

◆ ME_Remove()

void ME_Remove ( ME_DisplayItem * diWhere )

Definition at line 35 of file list.c.

{
  ME_DisplayItem *diNext = diWhere->next;
  ME_DisplayItem *diPrev = diWhere->prev;
  assert(diNext);
  assert(diPrev);
  diPrev->next = diNext;
  diNext->prev = diPrev;
}

Referenced by ME_InternalDeleteText(), ME_PrepareParagraphForWrapping(), para_join(), and run_join().

◆ ME_Repaint()

void ME_Repaint ( ME_TextEditor * editor )

Definition at line 119 of file paint.c.

{
  if (ME_WrapMarkedParagraphs(editor))
  {
    ME_UpdateScrollBar(editor);
    FIXME("ME_Repaint had to call ME_WrapMarkedParagraphs\n");
  }
  ITextHost_TxViewChange(editor->texthost, TRUE);
}

Referenced by editor_handle_message(), ME_ArrowKey(), ME_RewrapRepaint(), scroll_abs(), and table_handle_tab().

◆ ME_ReplaceSel()

void ME_ReplaceSel	(	ME_TextEditor *	editor,
		BOOL	can_undo,
		const WCHAR *	str,
		int	len
	)

Definition at line 3161 of file editor.c.

{
  int from, to, nStartCursor;
  ME_Style *style;
 
  nStartCursor = ME_GetSelectionOfs(editor, &from, &to);
  style = ME_GetSelectionInsertStyle(editor);
  ME_InternalDeleteText(editor, &editor->pCursors[nStartCursor], to-from, FALSE);
  ME_InsertTextFromCursor(editor, 0, str, len, style);
  ME_ReleaseStyle(style);
  /* drop temporary style if line end */
  /*
   * FIXME question: does abc\n mean: put abc,
   * clear temp style, put \n? (would require a change)
   */
  if (len>0 && str[len-1] == '\n')
    ME_ClearTempStyle(editor);
  ME_CommitUndo(editor);
  ME_UpdateSelectionLinkAttribute(editor);
  if (!can_undo)
    ME_EmptyUndoStack(editor);
  ME_UpdateRepaint(editor, FALSE);
}

Referenced by editor_handle_message(), and ITextSelection_fnSetText().

◆ ME_ReverseFindNonWhitespaceV()

int ME_ReverseFindNonWhitespaceV	(	const ME_String *	s,
		int	nVChar
	)

◆ ME_ReverseFindWhitespaceV()

int ME_ReverseFindWhitespaceV	(	const ME_String *	s,
		int	nVChar
	)

◆ ME_RewrapRepaint()

void ME_RewrapRepaint ( ME_TextEditor * editor )

Definition at line 156 of file paint.c.

{
  /* RewrapRepaint should be called whenever the control has changed in
   * looks, but not content. Like resizing. */
  
  editor_mark_rewrap_all( editor );
  ME_WrapMarkedParagraphs(editor);
  ME_UpdateScrollBar(editor);
  ME_Repaint(editor);
}

Referenced by editor_handle_message(), fnTextSrv_OnTxInPlaceActivate(), fnTextSrv_OnTxPropertyBitsChange(), and ME_SetZoom().

◆ ME_RTFCharAttrHook()

void ME_RTFCharAttrHook ( struct _RTF_Info * info )

Definition at line 428 of file editor.c.

{
  CHARFORMAT2W fmt;
  fmt.cbSize = sizeof(fmt);
  fmt.dwMask = 0;
  fmt.dwEffects = 0;
 
  switch(info->rtfMinor)
  {
    case rtfPlain:
      /* FIXME add more flags once they're implemented */
      fmt.dwMask = CFM_BOLD | CFM_ITALIC | CFM_UNDERLINE | CFM_UNDERLINETYPE | CFM_STRIKEOUT |
          CFM_COLOR | CFM_BACKCOLOR | CFM_SIZE | CFM_WEIGHT;
      fmt.dwEffects = CFE_AUTOCOLOR | CFE_AUTOBACKCOLOR;
      fmt.yHeight = 12*20; /* 12pt */
      fmt.wWeight = FW_NORMAL;
      fmt.bUnderlineType = CFU_UNDERLINE;
      break;
    case rtfBold:
      fmt.dwMask = CFM_BOLD | CFM_WEIGHT;
      fmt.dwEffects = info->rtfParam ? CFE_BOLD : 0;
      fmt.wWeight = info->rtfParam ? FW_BOLD : FW_NORMAL;
      break;
    case rtfItalic:
      fmt.dwMask = CFM_ITALIC;
      fmt.dwEffects = info->rtfParam ? fmt.dwMask : 0;
      break;
    case rtfUnderline:
      fmt.dwMask = CFM_UNDERLINETYPE | CFM_UNDERLINE;
      fmt.bUnderlineType = CFU_UNDERLINE;
      fmt.dwEffects = info->rtfParam ? CFE_UNDERLINE : 0;
      break;
    case rtfDotUnderline:
      fmt.dwMask = CFM_UNDERLINETYPE | CFM_UNDERLINE;
      fmt.bUnderlineType = CFU_UNDERLINEDOTTED;
      fmt.dwEffects = info->rtfParam ? CFE_UNDERLINE : 0;
      break;
    case rtfDbUnderline:
      fmt.dwMask = CFM_UNDERLINETYPE | CFM_UNDERLINE;
      fmt.bUnderlineType = CFU_UNDERLINEDOUBLE;
      fmt.dwEffects = info->rtfParam ? CFE_UNDERLINE : 0;
      break;
    case rtfWordUnderline:
      fmt.dwMask = CFM_UNDERLINETYPE | CFM_UNDERLINE;
      fmt.bUnderlineType = CFU_UNDERLINEWORD;
      fmt.dwEffects = info->rtfParam ? CFE_UNDERLINE : 0;
      break;
    case rtfNoUnderline:
      fmt.dwMask = CFM_UNDERLINE;
      fmt.dwEffects = 0;
      break;
    case rtfStrikeThru:
      fmt.dwMask = CFM_STRIKEOUT;
      fmt.dwEffects = info->rtfParam ? fmt.dwMask : 0;
      break;
    case rtfSubScript:
    case rtfSuperScript:
    case rtfSubScrShrink:
    case rtfSuperScrShrink:
    case rtfNoSuperSub:
      fmt.dwMask = CFM_SUBSCRIPT|CFM_SUPERSCRIPT;
      if (info->rtfMinor == rtfSubScrShrink) fmt.dwEffects = CFE_SUBSCRIPT;
      if (info->rtfMinor == rtfSuperScrShrink) fmt.dwEffects = CFE_SUPERSCRIPT;
      if (info->rtfMinor == rtfNoSuperSub) fmt.dwEffects = 0;
      break;
    case rtfInvisible:
      fmt.dwMask = CFM_HIDDEN;
      fmt.dwEffects = info->rtfParam ? fmt.dwMask : 0;
      break;
    case rtfBackColor:
      fmt.dwMask = CFM_BACKCOLOR;
      fmt.dwEffects = 0;
      if (info->rtfParam == 0)
        fmt.dwEffects = CFE_AUTOBACKCOLOR;
      else if (info->rtfParam != rtfNoParam)
      {
        RTFColor *c = RTFGetColor(info, info->rtfParam);
        if (c && c->rtfCBlue >= 0)
          fmt.crBackColor = (c->rtfCBlue<<16)|(c->rtfCGreen<<8)|(c->rtfCRed);
        else
          fmt.dwEffects = CFE_AUTOBACKCOLOR;
      }
      break;
    case rtfForeColor:
      fmt.dwMask = CFM_COLOR;
      fmt.dwEffects = 0;
      if (info->rtfParam == 0)
        fmt.dwEffects = CFE_AUTOCOLOR;
      else if (info->rtfParam != rtfNoParam)
      {
        RTFColor *c = RTFGetColor(info, info->rtfParam);
        if (c && c->rtfCBlue >= 0)
          fmt.crTextColor = (c->rtfCBlue<<16)|(c->rtfCGreen<<8)|(c->rtfCRed);
        else {
          fmt.dwEffects = CFE_AUTOCOLOR;
        }
      }
      break;
    case rtfFontNum:
      if (info->rtfParam != rtfNoParam)
      {
        RTFFont *f = RTFGetFont(info, info->rtfParam);
        if (f)
        {
          MultiByteToWideChar(CP_ACP, 0, f->rtfFName, -1, fmt.szFaceName, ARRAY_SIZE(fmt.szFaceName));
          fmt.szFaceName[ARRAY_SIZE(fmt.szFaceName)-1] = '\0';
          fmt.bCharSet = f->rtfFCharSet;
          fmt.dwMask = CFM_FACE | CFM_CHARSET;
          fmt.bPitchAndFamily = f->rtfFPitch | (f->rtfFFamily << 4);
        }
      }
      break;
    case rtfFontSize:
      fmt.dwMask = CFM_SIZE;
      if (info->rtfParam != rtfNoParam)
        fmt.yHeight = info->rtfParam*10;
      break;
  }
  if (fmt.dwMask) {
    ME_Style *style2;
    RTFFlushOutputBuffer(info);
    /* FIXME too slow ? how come ? */
    style2 = ME_ApplyStyle(info->editor, info->style, &fmt);
    ME_ReleaseStyle(info->style);
    info->style = style2;
    info->styleChanged = TRUE;
  }
}

Referenced by ControlClass().

◆ ME_RTFParAttrHook()

void ME_RTFParAttrHook ( struct _RTF_Info * info )

Definition at line 559 of file editor.c.

{
  switch(info->rtfMinor)
  {
  case rtfParDef: /* restores default paragraph attributes */
    if (!info->editor->bEmulateVersion10) /* v4.1 */
      info->borderType = RTFBorderParaLeft;
    else /* v1.0 - 3.0 */
      info->borderType = RTFBorderParaTop;
    info->fmt.dwMask = PFM_ALIGNMENT | PFM_BORDER | PFM_LINESPACING | PFM_TABSTOPS |
        PFM_OFFSET | PFM_RIGHTINDENT | PFM_SPACEAFTER | PFM_SPACEBEFORE |
        PFM_STARTINDENT | PFM_RTLPARA | PFM_NUMBERING | PFM_NUMBERINGSTART |
        PFM_NUMBERINGSTYLE | PFM_NUMBERINGTAB;
    /* TODO: shading */
    info->fmt.wAlignment = PFA_LEFT;
    info->fmt.cTabCount = 0;
    info->fmt.dxOffset = info->fmt.dxStartIndent = info->fmt.dxRightIndent = 0;
    info->fmt.wBorderWidth = info->fmt.wBorders = 0;
    info->fmt.wBorderSpace = 0;
    info->fmt.bLineSpacingRule = 0;
    info->fmt.dySpaceBefore = info->fmt.dySpaceAfter = 0;
    info->fmt.dyLineSpacing = 0;
    info->fmt.wEffects &= ~PFE_RTLPARA;
    info->fmt.wNumbering = 0;
    info->fmt.wNumberingStart = 0;
    info->fmt.wNumberingStyle = 0;
    info->fmt.wNumberingTab = 0;
 
    if (!info->editor->bEmulateVersion10) /* v4.1 */
    {
      if (info->tableDef && info->tableDef->row_start &&
          info->tableDef->row_start->nFlags & MEPF_ROWEND)
      {
        ME_Cursor cursor;
        ME_Paragraph *para;
        /* We are just after a table row. */
        RTFFlushOutputBuffer(info);
        cursor = info->editor->pCursors[0];
        para = cursor.para;
        if (para == para_next( info->tableDef->row_start )
            && !cursor.nOffset && !cursor.run->nCharOfs)
        {
          /* Since the table row end, no text has been inserted, and the \intbl
           * control word has not be used.  We can confirm that we are not in a
           * table anymore.
           */
          info->tableDef->row_start = NULL;
          info->canInheritInTbl = FALSE;
        }
      }
    }
    else /* v1.0 - v3.0 */
    {
      info->fmt.dwMask |= PFM_TABLE;
      info->fmt.wEffects &= ~PFE_TABLE;
    }
    break;
  case rtfNestLevel:
    if (!info->editor->bEmulateVersion10) /* v4.1 */
    {
      while (info->rtfParam > info->nestingLevel)
      {
        RTFTable *tableDef = heap_alloc_zero(sizeof(*tableDef));
        tableDef->parent = info->tableDef;
        info->tableDef = tableDef;
 
        RTFFlushOutputBuffer(info);
        if (tableDef->row_start && tableDef->row_start->nFlags & MEPF_ROWEND)
        {
          ME_Paragraph *para = para_next( tableDef->row_start );
          tableDef->row_start = table_insert_row_start_at_para( info->editor, para );
        }
        else
        {
          ME_Cursor cursor;
          cursor = info->editor->pCursors[0];
          if (cursor.nOffset || cursor.run->nCharOfs)
            ME_InsertTextFromCursor(info->editor, 0, L"\r", 1, info->style);
          tableDef->row_start = table_insert_row_start( info->editor, info->editor->pCursors );
        }
 
        info->nestingLevel++;
      }
      info->canInheritInTbl = FALSE;
    }
    break;
  case rtfInTable:
  {
    if (!info->editor->bEmulateVersion10) /* v4.1 */
    {
      if (info->nestingLevel < 1)
      {
        RTFTable *tableDef;
        ME_Paragraph *para;
 
        if (!info->tableDef)
            info->tableDef = heap_alloc_zero(sizeof(*info->tableDef));
        tableDef = info->tableDef;
        RTFFlushOutputBuffer(info);
        if (tableDef->row_start && tableDef->row_start->nFlags & MEPF_ROWEND)
          para = para_next( tableDef->row_start );
        else
          para = info->editor->pCursors[0].para;
 
        tableDef->row_start = table_insert_row_start_at_para( info->editor, para );
 
        info->nestingLevel = 1;
        info->canInheritInTbl = TRUE;
      }
      return;
    } else { /* v1.0 - v3.0 */
      info->fmt.dwMask |= PFM_TABLE;
      info->fmt.wEffects |= PFE_TABLE;
    }
    break;
  }
  case rtfFirstIndent:
  case rtfLeftIndent:
    if ((info->fmt.dwMask & (PFM_STARTINDENT | PFM_OFFSET)) != (PFM_STARTINDENT | PFM_OFFSET))
    {
      PARAFORMAT2 fmt;
      fmt.cbSize = sizeof(fmt);
      editor_get_selection_para_fmt( info->editor, &fmt );
      info->fmt.dwMask |= PFM_STARTINDENT | PFM_OFFSET;
      info->fmt.dxStartIndent = fmt.dxStartIndent;
      info->fmt.dxOffset = fmt.dxOffset;
    }
    if (info->rtfMinor == rtfFirstIndent)
    {
      info->fmt.dxStartIndent += info->fmt.dxOffset + info->rtfParam;
      info->fmt.dxOffset = -info->rtfParam;
    }
    else
      info->fmt.dxStartIndent = info->rtfParam - info->fmt.dxOffset;
    break;
  case rtfRightIndent:
    info->fmt.dwMask |= PFM_RIGHTINDENT;
    info->fmt.dxRightIndent = info->rtfParam;
    break;
  case rtfQuadLeft:
  case rtfQuadJust:
    info->fmt.dwMask |= PFM_ALIGNMENT;
    info->fmt.wAlignment = PFA_LEFT;
    break;
  case rtfQuadRight:
    info->fmt.dwMask |= PFM_ALIGNMENT;
    info->fmt.wAlignment = PFA_RIGHT;
    break;
  case rtfQuadCenter:
    info->fmt.dwMask |= PFM_ALIGNMENT;
    info->fmt.wAlignment = PFA_CENTER;
    break;
  case rtfTabPos:
    if (!(info->fmt.dwMask & PFM_TABSTOPS))
    {
      PARAFORMAT2 fmt;
      fmt.cbSize = sizeof(fmt);
      editor_get_selection_para_fmt( info->editor, &fmt );
      memcpy(info->fmt.rgxTabs, fmt.rgxTabs,
             fmt.cTabCount * sizeof(fmt.rgxTabs[0]));
      info->fmt.cTabCount = fmt.cTabCount;
      info->fmt.dwMask |= PFM_TABSTOPS;
    }
    if (info->fmt.cTabCount < MAX_TAB_STOPS && info->rtfParam < 0x1000000)
      info->fmt.rgxTabs[info->fmt.cTabCount++] = info->rtfParam;
    break;
  case rtfKeep:
    info->fmt.dwMask |= PFM_KEEP;
    info->fmt.wEffects |= PFE_KEEP;
    break;
  case rtfNoWidowControl:
    info->fmt.dwMask |= PFM_NOWIDOWCONTROL;
    info->fmt.wEffects |= PFE_NOWIDOWCONTROL;
    break;
  case rtfKeepNext:
    info->fmt.dwMask |= PFM_KEEPNEXT;
    info->fmt.wEffects |= PFE_KEEPNEXT;
    break;
  case rtfSpaceAfter:
    info->fmt.dwMask |= PFM_SPACEAFTER;
    info->fmt.dySpaceAfter = info->rtfParam;
    break;
  case rtfSpaceBefore:
    info->fmt.dwMask |= PFM_SPACEBEFORE;
    info->fmt.dySpaceBefore = info->rtfParam;
    break;
  case rtfSpaceBetween:
    info->fmt.dwMask |= PFM_LINESPACING;
    if ((int)info->rtfParam > 0)
    {
      info->fmt.dyLineSpacing = info->rtfParam;
      info->fmt.bLineSpacingRule = 3;
    }
    else
    {
      info->fmt.dyLineSpacing = info->rtfParam;
      info->fmt.bLineSpacingRule = 4;
    }
    break;
  case rtfSpaceMultiply:
    info->fmt.dwMask |= PFM_LINESPACING;
    info->fmt.dyLineSpacing = info->rtfParam * 20;
    info->fmt.bLineSpacingRule = 5;
    break;
  case rtfParBullet:
    info->fmt.dwMask |= PFM_NUMBERING;
    info->fmt.wNumbering = PFN_BULLET;
    break;
  case rtfParSimple:
    info->fmt.dwMask |= PFM_NUMBERING;
    info->fmt.wNumbering = 2; /* FIXME: MSDN says it's not used ?? */
    break;
  case rtfBorderLeft:
    info->borderType = RTFBorderParaLeft;
    info->fmt.wBorders |= 1;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  case rtfBorderRight:
    info->borderType = RTFBorderParaRight;
    info->fmt.wBorders |= 2;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  case rtfBorderTop:
    info->borderType = RTFBorderParaTop;
    info->fmt.wBorders |= 4;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  case rtfBorderBottom:
    info->borderType = RTFBorderParaBottom;
    info->fmt.wBorders |= 8;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  case rtfBorderSingle:
    info->fmt.wBorders &= ~0x700;
    info->fmt.wBorders |= 1 << 8;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  case rtfBorderThick:
    info->fmt.wBorders &= ~0x700;
    info->fmt.wBorders |= 2 << 8;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  case rtfBorderShadow:
    info->fmt.wBorders &= ~0x700;
    info->fmt.wBorders |= 10 << 8;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  case rtfBorderDouble:
    info->fmt.wBorders &= ~0x700;
    info->fmt.wBorders |= 7 << 8;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  case rtfBorderDot:
    info->fmt.wBorders &= ~0x700;
    info->fmt.wBorders |= 11 << 8;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  case rtfBorderWidth:
  {
    int borderSide = info->borderType & RTFBorderSideMask;
    RTFTable *tableDef = info->tableDef;
    if ((info->borderType & RTFBorderTypeMask) == RTFBorderTypeCell)
    {
      RTFBorder *border;
      if (!tableDef || tableDef->numCellsDefined >= MAX_TABLE_CELLS)
        break;
      border = &tableDef->cells[tableDef->numCellsDefined].border[borderSide];
      border->width = info->rtfParam;
      break;
    }
    info->fmt.wBorderWidth = info->rtfParam;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  }
  case rtfBorderSpace:
    info->fmt.wBorderSpace = info->rtfParam;
    info->fmt.dwMask |= PFM_BORDER;
    break;
  case rtfBorderColor:
  {
    RTFTable *tableDef = info->tableDef;
    int borderSide = info->borderType & RTFBorderSideMask;
    int borderType = info->borderType & RTFBorderTypeMask;
    switch(borderType)
    {
    case RTFBorderTypePara:
      if (!info->editor->bEmulateVersion10) /* v4.1 */
        break;
      /* v1.0 - 3.0 treat paragraph and row borders the same. */
    case RTFBorderTypeRow:
      if (tableDef) {
        tableDef->border[borderSide].color = info->rtfParam;
      }
      break;
    case RTFBorderTypeCell:
      if (tableDef && tableDef->numCellsDefined < MAX_TABLE_CELLS) {
        tableDef->cells[tableDef->numCellsDefined].border[borderSide].color = info->rtfParam;
      }
      break;
    }
    break;
  }
  case rtfRTLPar:
    info->fmt.dwMask |= PFM_RTLPARA;
    info->fmt.wEffects |= PFE_RTLPARA;
    break;
  case rtfLTRPar:
    info->fmt.dwMask |= PFM_RTLPARA;
    info->fmt.wEffects &= ~PFE_RTLPARA;
    break;
  }
}

Referenced by ControlClass().

◆ ME_RTFSpecialCharHook()

void ME_RTFSpecialCharHook ( struct _RTF_Info * info )

Definition at line 946 of file editor.c.

{
  RTFTable *tableDef = info->tableDef;
  switch (info->rtfMinor)
  {
    case rtfNestCell:
      if (info->editor->bEmulateVersion10) /* v1.0 - v3.0 */
        break;
      /* else fall through since v4.1 treats rtfNestCell and rtfCell the same */
    case rtfCell:
      if (!tableDef)
        break;
      RTFFlushOutputBuffer(info);
      if (!info->editor->bEmulateVersion10) /* v4.1 */
      {
        if (tableDef->row_start)
        {
          if (!info->nestingLevel && tableDef->row_start->nFlags & MEPF_ROWEND)
          {
            ME_Paragraph *para = para_next( tableDef->row_start );
            tableDef->row_start = table_insert_row_start_at_para( info->editor, para );
            info->nestingLevel = 1;
          }
          table_insert_cell( info->editor, info->editor->pCursors );
        }
      }
      else /* v1.0 - v3.0 */
      {
        ME_Paragraph *para = info->editor->pCursors[0].para;
 
        if (para_in_table( para ) && tableDef->numCellsInserted < tableDef->numCellsDefined)
        {
          WCHAR tab = '\t';
          ME_InsertTextFromCursor(info->editor, 0, &tab, 1, info->style);
          tableDef->numCellsInserted++;
        }
      }
      break;
    case rtfNestRow:
      if (info->editor->bEmulateVersion10) /* v1.0 - v3.0 */
        break;
      /* else fall through since v4.1 treats rtfNestRow and rtfRow the same */
    case rtfRow:
    {
      ME_Run *run;
      ME_Paragraph *para;
      ME_Cell *cell;
      int i;
 
      if (!tableDef)
        break;
      RTFFlushOutputBuffer(info);
      if (!info->editor->bEmulateVersion10) /* v4.1 */
      {
        if (!tableDef->row_start) break;
        if (!info->nestingLevel && tableDef->row_start->nFlags & MEPF_ROWEND)
        {
          para = para_next( tableDef->row_start );
          tableDef->row_start = table_insert_row_start_at_para( info->editor, para );
          info->nestingLevel++;
        }
        para = tableDef->row_start;
        cell = table_row_first_cell( para );
        assert( cell && !cell_prev( cell ) );
        if (tableDef->numCellsDefined < 1)
        {
          /* 2000 twips appears to be the cell size that native richedit uses
           * when no cell sizes are specified. */
          const int default_size = 2000;
          int right_boundary = default_size;
          cell->nRightBoundary = right_boundary;
          while (cell_next( cell ))
          {
            cell = cell_next( cell );
            right_boundary += default_size;
            cell->nRightBoundary = right_boundary;
          }
          para = table_insert_cell( info->editor, info->editor->pCursors );
          cell = para_cell( para );
          cell->nRightBoundary = right_boundary;
        }
        else
        {
          for (i = 0; i < tableDef->numCellsDefined; i++)
          {
            RTFCell *cellDef = &tableDef->cells[i];
            cell->nRightBoundary = cellDef->rightBoundary;
            ME_ApplyBorderProperties( info, &cell->border, cellDef->border );
            cell = cell_next( cell );
            if (!cell)
            {
              para = table_insert_cell( info->editor, info->editor->pCursors );
              cell = para_cell( para );
            }
          }
          /* Cell for table row delimiter is empty */
          cell->nRightBoundary = tableDef->cells[i - 1].rightBoundary;
        }
 
        run = para_first_run( cell_first_para( cell ) );
        if (info->editor->pCursors[0].run != run || info->editor->pCursors[0].nOffset)
        {
          int nOfs, nChars;
          /* Delete inserted cells that aren't defined. */
          info->editor->pCursors[1].run = run;
          info->editor->pCursors[1].para = run->para;
          info->editor->pCursors[1].nOffset = 0;
          nOfs = ME_GetCursorOfs(&info->editor->pCursors[1]);
          nChars = ME_GetCursorOfs(&info->editor->pCursors[0]) - nOfs;
          ME_InternalDeleteText(info->editor, &info->editor->pCursors[1],
                                nChars, TRUE);
        }
 
        para = table_insert_row_end( info->editor, info->editor->pCursors );
        para->fmt.dxOffset = abs(info->tableDef->gapH);
        para->fmt.dxStartIndent = info->tableDef->leftEdge;
        ME_ApplyBorderProperties( info, &para->border, tableDef->border );
        info->nestingLevel--;
        if (!info->nestingLevel)
        {
          if (info->canInheritInTbl) tableDef->row_start = para;
          else
          {
            while (info->tableDef)
            {
              tableDef = info->tableDef;
              info->tableDef = tableDef->parent;
              heap_free(tableDef);
            }
          }
        }
        else
        {
          info->tableDef = tableDef->parent;
          heap_free(tableDef);
        }
      }
      else /* v1.0 - v3.0 */
      {
        para = info->editor->pCursors[0].para;
        para->fmt.dxOffset = info->tableDef->gapH;
        para->fmt.dxStartIndent = info->tableDef->leftEdge;
 
        ME_ApplyBorderProperties( info, &para->border, tableDef->border );
        while (tableDef->numCellsInserted < tableDef->numCellsDefined)
        {
          WCHAR tab = '\t';
          ME_InsertTextFromCursor(info->editor, 0, &tab, 1, info->style);
          tableDef->numCellsInserted++;
        }
        para->fmt.cTabCount = min(tableDef->numCellsDefined, MAX_TAB_STOPS);
        if (!tableDef->numCellsDefined) para->fmt.wEffects &= ~PFE_TABLE;
        ME_InsertTextFromCursor(info->editor, 0, L"\r", 1, info->style);
        tableDef->numCellsInserted = 0;
      }
      break;
    }
    case rtfTab:
    case rtfPar:
      if (info->editor->bEmulateVersion10) /* v1.0 - 3.0 */
      {
        ME_Paragraph *para;
 
        RTFFlushOutputBuffer(info);
        para = info->editor->pCursors[0].para;
        if (para_in_table( para ))
        {
          /* rtfPar is treated like a space within a table. */
          info->rtfClass = rtfText;
          info->rtfMajor = ' ';
        }
        else if (info->rtfMinor == rtfPar && tableDef)
          tableDef->numCellsInserted = 0;
      }
      break;
  }
}

Referenced by ControlClass(), and ME_StreamIn().

◆ ME_RTFTblAttrHook()

void ME_RTFTblAttrHook ( struct _RTF_Info * info )

Definition at line 872 of file editor.c.

{
  switch (info->rtfMinor)
  {
    case rtfRowDef:
    {
      if (!info->editor->bEmulateVersion10) /* v4.1 */
        info->borderType = 0; /* Not sure */
      else /* v1.0 - 3.0 */
        info->borderType = RTFBorderRowTop;
      if (!info->tableDef) {
        info->tableDef = ME_MakeTableDef(info->editor);
      } else {
        ME_InitTableDef(info->editor, info->tableDef);
      }
      break;
    }
    case rtfCellPos:
    {
      int cellNum;
      if (!info->tableDef)
      {
        info->tableDef = ME_MakeTableDef(info->editor);
      }
      cellNum = info->tableDef->numCellsDefined;
      if (cellNum >= MAX_TABLE_CELLS)
        break;
      info->tableDef->cells[cellNum].rightBoundary = info->rtfParam;
      if (cellNum < MAX_TAB_STOPS)
      {
        /* Tab stops were used to store cell positions before v4.1 but v4.1
         * still seems to set the tabstops without using them. */
        PARAFORMAT2 *fmt = &info->editor->pCursors[0].para->fmt;
        fmt->rgxTabs[cellNum] &= ~0x00FFFFFF;
        fmt->rgxTabs[cellNum] |= 0x00FFFFFF & info->rtfParam;
      }
      info->tableDef->numCellsDefined++;
      break;
    }
    case rtfRowBordTop:
      info->borderType = RTFBorderRowTop;
      break;
    case rtfRowBordLeft:
      info->borderType = RTFBorderRowLeft;
      break;
    case rtfRowBordBottom:
      info->borderType = RTFBorderRowBottom;
      break;
    case rtfRowBordRight:
      info->borderType = RTFBorderRowRight;
      break;
    case rtfCellBordTop:
      info->borderType = RTFBorderCellTop;
      break;
    case rtfCellBordLeft:
      info->borderType = RTFBorderCellLeft;
      break;
    case rtfCellBordBottom:
      info->borderType = RTFBorderCellBottom;
      break;
    case rtfCellBordRight:
      info->borderType = RTFBorderCellRight;
      break;
    case rtfRowGapH:
      if (info->tableDef)
        info->tableDef->gapH = info->rtfParam;
      break;
    case rtfRowLeftEdge:
      if (info->tableDef)
        info->tableDef->leftEdge = info->rtfParam;
      break;
  }
}

Referenced by ControlClass().

◆ ME_SaveTempStyle()

void ME_SaveTempStyle	(	ME_TextEditor *	editor,
		ME_Style *	style
	)

Definition at line 498 of file style.c.

{
  ME_Style *old_style = editor->pBuffer->pCharStyle;
 
  if (style) ME_AddRefStyle( style );
  editor->pBuffer->pCharStyle = style;
  if (old_style) ME_ReleaseStyle( old_style );
}

Referenced by editor_handle_message(), and handle_enter().

◆ ME_ScrollDown()

void ME_ScrollDown	(	ME_TextEditor *	editor,
		int	cy
	)

Definition at line 1132 of file paint.c.

{
    scroll_v_abs( editor, editor->vert_si.nPos + cy, TRUE );
}

Referenced by editor_handle_message(), and ME_ArrowPageDown().

◆ ME_ScrollLeft()

void ME_ScrollLeft	(	ME_TextEditor *	editor,
		int	cx
	)

Definition at line 1137 of file paint.c.

{
    scroll_h_abs( editor, editor->horz_si.nPos - cx, TRUE );
}

Referenced by editor_handle_message().

◆ ME_ScrollRight()

void ME_ScrollRight	(	ME_TextEditor *	editor,
		int	cx
	)

Definition at line 1142 of file paint.c.

{
    scroll_h_abs( editor, editor->horz_si.nPos + cx, TRUE );
}

Referenced by editor_handle_message().

◆ ME_ScrollUp()

void ME_ScrollUp	(	ME_TextEditor *	editor,
		int	cy
	)

Definition at line 1127 of file paint.c.

{
    scroll_v_abs( editor, editor->vert_si.nPos - cy, TRUE );
}

Referenced by editor_handle_message(), and ME_ArrowPageUp().

◆ ME_SendRequestResize()

void ME_SendRequestResize	(	ME_TextEditor *	editor,
		BOOL	force
	)

Definition at line 1128 of file wrap.c.

{
  if (editor->nEventMask & ENM_REQUESTRESIZE)
  {
    RECT rc;
 
    ITextHost_TxGetClientRect(editor->texthost, &rc);
 
    if (force || rc.bottom != editor->nTotalLength)
    {
      REQRESIZE info;
 
      info.nmhdr.hwndFrom = NULL;
      info.nmhdr.idFrom = 0;
      info.nmhdr.code = EN_REQUESTRESIZE;
      info.rc = rc;
      info.rc.right = editor->nTotalWidth;
      info.rc.bottom = editor->nTotalLength;
 
      editor->nEventMask &= ~ENM_REQUESTRESIZE;
      ITextHost_TxNotify(editor->texthost, info.nmhdr.code, &info);
      editor->nEventMask |= ENM_REQUESTRESIZE;
    }
  }
}

Referenced by editor_draw(), editor_handle_message(), ME_KeyDown(), and ME_StreamIn().

◆ ME_SendSelChange()

void ME_SendSelChange ( ME_TextEditor * editor )

Definition at line 1420 of file caret.c.

{
  SELCHANGE sc;
 
  sc.nmhdr.hwndFrom = NULL;
  sc.nmhdr.idFrom = 0;
  sc.nmhdr.code = EN_SELCHANGE;
  ME_GetSelectionOfs(editor, &sc.chrg.cpMin, &sc.chrg.cpMax);
  sc.seltyp = SEL_EMPTY;
  if (sc.chrg.cpMin != sc.chrg.cpMax)
    sc.seltyp |= SEL_TEXT;
  if (sc.chrg.cpMin < sc.chrg.cpMax+1) /* what were RICHEDIT authors thinking ? */
    sc.seltyp |= SEL_MULTICHAR;
 
  if (sc.chrg.cpMin != editor->notified_cr.cpMin || sc.chrg.cpMax != editor->notified_cr.cpMax)
  {
    ME_ClearTempStyle(editor);
 
    editor->notified_cr = sc.chrg;
 
    if (editor->nEventMask & ENM_SELCHANGE)
    {
      TRACE("cpMin=%d cpMax=%d seltyp=%d (%s %s)\n",
            sc.chrg.cpMin, sc.chrg.cpMax, sc.seltyp,
            (sc.seltyp & SEL_TEXT) ? "SEL_TEXT" : "",
            (sc.seltyp & SEL_MULTICHAR) ? "SEL_MULTICHAR" : "");
      ITextHost_TxNotify(editor->texthost, sc.nmhdr.code, &sc);
    }
  }
}

Referenced by ME_ArrowKey(), ME_LButtonDown(), ME_MouseMove(), ME_StreamIn(), ME_UpdateRepaint(), set_selection(), and table_handle_tab().

◆ ME_SetCharFormat()

void ME_SetCharFormat	(	ME_TextEditor *	editor,
		ME_Cursor *	start,
		ME_Cursor *	end,
		CHARFORMAT2W *	pFmt
	)

Definition at line 777 of file run.c.

{
  ME_Run *run, *start_run = start->run, *end_run = NULL;
 
  if (end && start->run == end->run && start->nOffset == end->nOffset)
    return;
 
  if (start->nOffset == start->run->len)
    start_run = run_next_all_paras( start->run );
  else if (start->nOffset)
  {
    /* run_split() may or may not update the cursors, depending on whether they
     * are selection cursors, but we need to make sure they are valid. */
    int split_offset = start->nOffset;
    ME_Run *split_run = run_split( editor, start );
    start_run = start->run;
    if (end && end->run == split_run)
    {
      end->run = start->run;
      end->nOffset -= split_offset;
    }
  }
 
  if (end)
  {
    if (end->nOffset == end->run->len)
      end_run = run_next_all_paras( end->run );
    else
    {
      if (end->nOffset) run_split( editor, end );
      end_run = end->run;
    }
  }
 
  for (run = start_run; run != end_run; run = run_next_all_paras( run ))
  {
    ME_Style *new_style = ME_ApplyStyle( editor, run->style, fmt );
    ME_Paragraph *para = run->para;
 
    add_undo_set_char_fmt( editor, para->nCharOfs + run->nCharOfs,
                           run->len, &run->style->fmt );
    ME_ReleaseStyle( run->style );
    run->style = new_style;
 
    /* The para numbering style depends on the eop style */
    if ((run->nFlags & MERF_ENDPARA) && para->para_num.style)
    {
      ME_ReleaseStyle(para->para_num.style);
      para->para_num.style = NULL;
    }
    para_mark_rewrap( editor, para );
  }
}

Referenced by editor_handle_message(), handle_EM_SETCHARFORMAT(), ME_PlayUndoItem(), ME_SetSelectionCharFormat(), ME_UpdateLinkAttribute(), para_join(), set_textfont_prop(), and textrange_set_font().

◆ ME_SetCursorToStart()

void ME_SetCursorToStart	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor
	)

Definition at line 27 of file caret.c.

{
  cursor->para = editor_first_para( editor );
  cursor->run = para_first_run( cursor->para );
  cursor->nOffset = 0;
}

Referenced by cursor_move_line(), editor_handle_message(), fnTextSrv_TxSetText(), handle_EM_SETCHARFORMAT(), ME_ArrowCtrlHome(), ME_ArrowPageUp(), ME_GetTextEx(), ME_MakeEditor(), ME_MoveCursorChars(), ME_SelectByType(), ME_StreamOut(), and set_selection_cursors().

◆ ME_SetDefaultCharFormat()

void ME_SetDefaultCharFormat	(	ME_TextEditor *	editor,
		CHARFORMAT2W *	mod
	)

Definition at line 524 of file style.c.

{
    ME_Style *style, *def = editor->pBuffer->pDefaultStyle;
 
    assert(mod->cbSize == sizeof(CHARFORMAT2W));
    style = ME_ApplyStyle(editor, def, mod);
    def->fmt = style->fmt;
    def->tm = style->tm;
    if (def->font_cache)
    {
        release_font_cache( def->font_cache );
        def->font_cache = NULL;
    }
    ScriptFreeCache( &def->script_cache );
    ME_ReleaseStyle( style );
    editor_mark_rewrap_all( editor );
}

Referenced by editor_handle_message(), handle_EM_SETCHARFORMAT(), and ME_MakeFirstParagraph().

◆ ME_SetSelectionCharFormat()

void ME_SetSelectionCharFormat	(	ME_TextEditor *	editor,
		CHARFORMAT2W *	pFmt
	)

Definition at line 748 of file run.c.

{
  if (!ME_IsSelection(editor))
  {
    ME_Style *s;
    if (!editor->pBuffer->pCharStyle)
      editor->pBuffer->pCharStyle = style_get_insert_style( editor, editor->pCursors );
    s = ME_ApplyStyle(editor, editor->pBuffer->pCharStyle, pFmt);
    ME_ReleaseStyle(editor->pBuffer->pCharStyle);
    editor->pBuffer->pCharStyle = s;
  } else {
    ME_Cursor *from, *to;
    ME_GetSelection(editor, &from, &to);
    ME_SetCharFormat(editor, from, to, pFmt);
  }
}

Referenced by editor_handle_message(), handle_EM_SETCHARFORMAT(), and ME_StreamIn().

◆ ME_SetZoom()

BOOL ME_SetZoom	(	ME_TextEditor *	editor,
		int	numerator,
		int	denominator
	)

Definition at line 1304 of file paint.c.

{
  /* TODO: Zoom images and objects */
 
  if (numerator == 0 && denominator == 0)
  {
    editor->nZoomNumerator = editor->nZoomDenominator = 0;
    return TRUE;
  }
  if (numerator <= 0 || denominator <= 0)
    return FALSE;
  if (numerator * 64 <= denominator || numerator / denominator >= 64)
    return FALSE;
 
  editor->nZoomNumerator = numerator;
  editor->nZoomDenominator = denominator;
 
  ME_RewrapRepaint(editor);
  return TRUE;
}

Referenced by editor_handle_message().

◆ ME_StrDeleteV()

void ME_StrDeleteV	(	ME_String *	s,
		int	nVChar,
		int	nChars
	)

Definition at line 147 of file string.c.

{
  int end_ofs = nVChar + nChars;
 
  assert(s->nBuffer); /* Not a const string */
  assert(nChars >= 0);
  assert(nVChar >= 0);
  assert(end_ofs <= s->nLen);
 
  memmove(s->szData + nVChar, s->szData + end_ofs,
          (s->nLen - end_ofs + 1) * sizeof(WCHAR));
  s->nLen -= nChars;
}

Referenced by ME_InternalDeleteText().

◆ ME_StreamInFill()

void ME_StreamInFill ( ME_InStream * stream )

Definition at line 1566 of file editor.c.

{
  stream->editstream->dwError = stream->editstream->pfnCallback(stream->editstream->dwCookie,
                                                                (BYTE *)stream->buffer,
                                                                sizeof(stream->buffer),
                                                                (LONG *)&stream->dwSize);
  stream->dwUsed = 0;
}

Referenced by _RTFGetChar(), ME_StreamIn(), and ME_StreamInText().

◆ ME_StreamOut()

LRESULT ME_StreamOut	(	ME_TextEditor *	editor,
		DWORD	dwFormat,
		EDITSTREAM *	stream
	)

Definition at line 1195 of file writer.c.

{
  ME_Cursor start;
  int nChars;
 
  if (dwFormat & SFF_SELECTION) {
    int nStart, nTo;
    start = editor->pCursors[ME_GetSelectionOfs(editor, &nStart, &nTo)];
    nChars = nTo - nStart;
  } else {
    ME_SetCursorToStart(editor, &start);
    nChars = ME_GetTextLength(editor);
    /* Generate an end-of-paragraph at the end of SCF_ALL RTF output */
    if (dwFormat & SF_RTF)
      nChars++;
  }
  return ME_StreamOutRange(editor, dwFormat, &start, nChars, stream);
}

Referenced by editor_handle_message().

◆ ME_StreamOutRange()

LRESULT ME_StreamOutRange	(	ME_TextEditor *	editor,
		DWORD	dwFormat,
		const ME_Cursor *	start,
		int	nChars,
		EDITSTREAM *	stream
	)

Definition at line 1179 of file writer.c.

{
  ME_OutStream *pStream = ME_StreamOutInit(editor, stream);
 
  if (dwFormat & SF_RTF)
    ME_StreamOutRTF(editor, pStream, start, nChars, dwFormat);
  else if (dwFormat & SF_TEXT || dwFormat & SF_TEXTIZED)
    ME_StreamOutText(editor, pStream, start, nChars, dwFormat);
  if (!pStream->stream->dwError)
    ME_StreamOutFlush(pStream);
  return ME_StreamOutFree(pStream);
}

Referenced by get_rtf_text(), and ME_StreamOut().

◆ ME_ToUnicode()

LPWSTR ME_ToUnicode	(	LONG	codepage,
		LPVOID	psz,
		INT *	len
	)

Definition at line 226 of file string.c.

{
  *len = 0;
  if (!psz) return NULL;
 
  if (codepage == CP_UNICODE)
  {
    *len = lstrlenW(psz);
    return psz;
  }
  else {
    WCHAR *tmp;
    int nChars = MultiByteToWideChar(codepage, 0, psz, -1, NULL, 0);
 
    if(!nChars) return NULL;
 
    if((tmp = heap_alloc( nChars * sizeof(WCHAR) )) != NULL)
      *len = MultiByteToWideChar(codepage, 0, psz, -1, tmp, nChars) - 1;
    return tmp;
  }
}

Referenced by editor_handle_message(), ME_SetText(), and RichEditWndProc_common().

◆ ME_twips2pointsX()

int ME_twips2pointsX	(	const ME_Context *	c,
		int	x
	)

Definition at line 167 of file paint.c.

{
  if (c->editor->nZoomNumerator == 0)
    return x * c->dpi.cx / 1440;
  else
    return x * c->dpi.cx * c->editor->nZoomNumerator / 1440 / c->editor->nZoomDenominator;
}

Referenced by adjust_para_y(), draw_table_borders(), ME_BeginRow(), ME_GetRunSizeCommon(), ME_InitContext(), and ME_WrapTextParagraph().

◆ ME_twips2pointsY()

int ME_twips2pointsY	(	const ME_Context *	c,
		int	y
	)

Definition at line 175 of file paint.c.

{
  if (c->editor->nZoomNumerator == 0)
    return y * c->dpi.cy / 1440;
  else
    return y * c->dpi.cy * c->editor->nZoomNumerator / 1440 / c->editor->nZoomDenominator;
}

Referenced by adjust_para_y(), calc_y_offset(), draw_table_borders(), ME_DrawParaDecoration(), ME_GetParaLineSpace(), ME_LogFontFromStyle(), and ME_WrapTextParagraph().

◆ ME_Undo()

BOOL ME_Undo ( ME_TextEditor * editor )

Definition at line 410 of file undo.c.

{
  ME_UndoMode nMode = editor->nUndoMode;
  struct list *head;
  struct undo_item *undo, *cursor2;
 
  if (editor->nUndoMode == umIgnore) return FALSE;
  assert(nMode == umAddToUndo || nMode == umIgnore);
 
  head = list_head( &editor->undo_stack );
  if (!head) return FALSE;
 
  /* watch out for uncommitted transactions ! */
  undo = LIST_ENTRY( head, struct undo_item, entry );
  assert(undo->type == undo_end_transaction
        || undo->type == undo_potential_end_transaction);
 
  editor->nUndoMode = umAddToRedo;
 
  list_remove( &undo->entry );
  destroy_undo_item( undo );
 
  LIST_FOR_EACH_ENTRY_SAFE( undo, cursor2, &editor->undo_stack, struct undo_item, entry )
  {
      if (undo->type == undo_end_transaction) break;
      ME_PlayUndoItem( editor, undo );
      list_remove( &undo->entry );
      destroy_undo_item( undo );
  }
 
  table_move_from_row_start( editor );
  add_undo( editor, undo_end_transaction );
  editor->nUndoStackSize--;
  editor->nUndoMode = nMode;
  ME_UpdateRepaint(editor, FALSE);
  return TRUE;
}

Referenced by editor_handle_message(), and ME_KeyDown().

◆ ME_UpdateRepaint()

void ME_UpdateRepaint	(	ME_TextEditor *	editor,
		BOOL	update_now
	)

Definition at line 129 of file paint.c.

{
  /* Should be called whenever the contents of the control have changed */
  BOOL wrappedParagraphs;
 
  wrappedParagraphs = ME_WrapMarkedParagraphs(editor);
  if (wrappedParagraphs)
    ME_UpdateScrollBar(editor);
 
  /* Ensure that the cursor is visible */
  editor_ensure_visible( editor, &editor->pCursors[0] );
 
  update_caret( editor );
 
  ITextHost_TxViewChange(editor->texthost, update_now);
 
  ME_SendSelChange(editor);
 
  if(editor->nEventMask & ENM_CHANGE)
  {
    editor->nEventMask &= ~ENM_CHANGE;
    ITextHost_TxNotify( editor->texthost, EN_CHANGE, NULL );
    editor->nEventMask |= ENM_CHANGE;
  }
}

Referenced by editor_copy_or_cut(), editor_handle_message(), fnTextSrv_TxSetText(), handle_enter(), handle_wm_char(), IRichEditOle_fnInsertObject(), ME_KeyDown(), ME_Redo(), ME_ReplaceSel(), ME_StreamIn(), ME_Undo(), and paste_emf().

◆ ME_UpdateRunFlags()

void ME_UpdateRunFlags	(	ME_TextEditor *	editor,
		ME_Run *	run
	)

Definition at line 462 of file run.c.

{
  assert(run->nCharOfs >= 0);
 
  if (RUN_IS_HIDDEN(run) || run->nFlags & MERF_TABLESTART)
    run->nFlags |= MERF_HIDDEN;
  else
    run->nFlags &= ~MERF_HIDDEN;
 
  if (run_is_splittable( run ))
    run->nFlags |= MERF_SPLITTABLE;
  else
    run->nFlags &= ~MERF_SPLITTABLE;
 
  if (!(run->nFlags & MERF_NOTEXT))
  {
    if (run_is_entirely_ws( run ))
      run->nFlags |= MERF_WHITESPACE | MERF_STARTWHITE | MERF_ENDWHITE;
    else
    {
      run->nFlags &= ~MERF_WHITESPACE;
 
      if (ME_IsWSpace( *get_text( run, 0 ) ))
        run->nFlags |= MERF_STARTWHITE;
      else
        run->nFlags &= ~MERF_STARTWHITE;
 
      if (ME_IsWSpace( *get_text( run, run->len - 1 ) ))
        run->nFlags |= MERF_ENDWHITE;
      else
        run->nFlags &= ~MERF_ENDWHITE;
    }
  }
  else
    run->nFlags &= ~(MERF_WHITESPACE | MERF_STARTWHITE | MERF_ENDWHITE);
}

Referenced by ME_SplitByBacktracking(), ME_WrapSizeRun(), run_join(), and run_split().

◆ ME_UpdateScrollBar()

void ME_UpdateScrollBar ( ME_TextEditor * editor )

Definition at line 1147 of file paint.c.

{
  /* Note that this is the only function that should ever call
   * SetScrollInfo with SIF_PAGE or SIF_RANGE. */
  BOOL enable;
 
  if (ME_WrapMarkedParagraphs(editor))
    FIXME("ME_UpdateScrollBar had to call ME_WrapMarkedParagraphs\n");
 
  /* Update horizontal scrollbar */
  enable = editor->nTotalWidth > editor->sizeWindow.cx;
  if (editor->horz_si.nPos && !enable)
  {
    scroll_h_abs( editor, 0, TRUE );
    /* ME_HScrollAbs will call this function, so nothing else needs to be done here. */
    return;
  }
 
  if (editor->scrollbars & WS_HSCROLL && !enable ^ !editor->horz_sb_enabled)
  {
    editor->horz_sb_enabled = enable;
    enable_show_scrollbar( editor, SB_HORZ, enable );
  }
 
  if (editor->horz_si.nMax != editor->nTotalWidth || editor->horz_si.nPage != editor->sizeWindow.cx)
  {
    editor->horz_si.nMax = editor->nTotalWidth;
    editor->horz_si.nPage = editor->sizeWindow.cx;
    TRACE( "min = %d max = %d page = %d\n", editor->horz_si.nMin, editor->horz_si.nMax, editor->horz_si.nPage );
    if ((enable || editor->horz_sb_enabled) && editor->scrollbars & WS_HSCROLL)
      set_scroll_range_pos( editor, SB_HORZ, &editor->horz_si, TRUE, TRUE );
  }
 
  /* Update vertical scrollbar */
  enable = editor->nTotalLength > editor->sizeWindow.cy && (editor->props & TXTBIT_MULTILINE);
 
  if (editor->vert_si.nPos && !enable)
  {
    scroll_v_abs( editor, 0, TRUE );
    /* ME_VScrollAbs will call this function, so nothing else needs to be done here. */
    return;
  }
 
  if (editor->scrollbars & WS_VSCROLL && !enable ^ !editor->vert_sb_enabled)
  {
    editor->vert_sb_enabled = enable;
    enable_show_scrollbar( editor, SB_VERT, enable );
  }
 
  if (editor->vert_si.nMax != editor->nTotalLength || editor->vert_si.nPage != editor->sizeWindow.cy)
  {
    editor->vert_si.nMax = editor->nTotalLength;
    editor->vert_si.nPage = editor->sizeWindow.cy;
    TRACE( "min = %d max = %d page = %d\n", editor->vert_si.nMin, editor->vert_si.nMax, editor->vert_si.nPage );
    if ((enable || editor->vert_sb_enabled) && editor->scrollbars & WS_VSCROLL)
      set_scroll_range_pos( editor, SB_VERT, &editor->vert_si, TRUE, TRUE );
  }
}

Referenced by editor_handle_message(), handle_EM_SETCHARFORMAT(), ME_Repaint(), ME_RewrapRepaint(), ME_UpdateRepaint(), and scroll_abs().

◆ ME_VSplitString()

ME_String * ME_VSplitString	(	ME_String *	orig,
		int	nVPos
	)

Definition at line 131 of file string.c.

{
  ME_String *s;
 
  assert(orig->nBuffer); /* Not a const string */
  assert(charidx>=0);
  assert(charidx<=orig->nLen);
 
  s = ME_MakeStringN(orig->szData+charidx, orig->nLen-charidx);
  if (!s) return NULL;
 
  orig->nLen = charidx;
  orig->szData[charidx] = '\0';
  return s;
}

Referenced by para_join(), and para_split().

◆ ME_WrapMarkedParagraphs()

BOOL ME_WrapMarkedParagraphs ( ME_TextEditor * editor )

Definition at line 1094 of file wrap.c.

{
    HDC hdc = ITextHost_TxGetDC( editor->texthost );
    BOOL ret = wrap_marked_paras_dc( editor, hdc, TRUE );
    ITextHost_TxReleaseDC( editor->texthost, hdc );
    return ret;
}

Referenced by editor_handle_message(), handle_EM_SETCHARFORMAT(), ME_InvalidateSelection(), ME_Repaint(), ME_RewrapRepaint(), ME_UpdateRepaint(), ME_UpdateScrollBar(), and table_select_next_cell_or_append().

◆ para_cell()

ME_Cell * para_cell ( ME_Paragraph * para )

Definition at line 127 of file para.c.

{
    return para->cell;
}

Referenced by adjust_para_y(), cursor_move_line(), draw_paragraph(), draw_table_borders(), editor_draw(), ME_BeginRow(), ME_PlayUndoItem(), ME_RTFSpecialCharHook(), ME_WrapTextParagraph(), para_split(), pixel_pos_in_table_row(), stream_out_font_and_colour_tbls(), table_append_row(), table_insert_row_start_at_para(), table_outer_para(), table_protect_partial_deletion(), table_row_end(), table_row_end_cell(), table_row_first_cell(), table_row_start(), table_select_next_cell_or_append(), and table_update_flags().

◆ para_destroy()

void para_destroy	(	ME_TextEditor *	editor,
		ME_Paragraph *	item
	)

Definition at line 42 of file para.c.

{
    if (para->nWidth == editor->nTotalWidth)
    {
        para->nWidth = 0;
        editor->nTotalWidth = get_total_width(editor);
    }
    editor->total_rows -= para->nRows;
    ME_DestroyString( para->text );
    para_num_clear( &para->para_num );
    para_mark_remove( editor, para );
    ME_DestroyDisplayItem( para_get_di( para ) );
}

Referenced by ME_DestroyEditor(), and para_join().

◆ para_end_row()

ME_Row * para_end_row ( ME_Paragraph * para )

Definition at line 141 of file para.c.

{
    ME_DisplayItem *item;
 
    para = para_next( para );
    item = ME_FindItemBack( para_get_di( para ), diStartRowOrParagraph );
    if (!item || item->type != diStartRow) return NULL;
    return &item->member.row;
}

Referenced by cursor_from_virtual_coords(), cursor_move_line(), and ME_ArrowPageDown().

◆ para_end_run()

ME_Run * para_end_run ( ME_Paragraph * para )

Definition at line 117 of file para.c.

{
    return para->eop_run;
}

Referenced by editor_handle_message(), handle_enter(), ME_ExtendAnchorSelection(), ME_GetTextW(), ME_InsertTextFromCursor(), ME_MoveCursorChars(), ME_MoveCursorWords(), ME_SelectByType(), ME_SetCursorToEnd(), para_join(), table_append_row(), table_protect_partial_deletion(), and table_select_next_cell_or_append().

◆ para_first_row()

ME_Row * para_first_row ( ME_Paragraph * para )

Definition at line 132 of file para.c.

{
    ME_DisplayItem *item;
 
    item = ME_FindItemFwd( para_get_di( para ), diStartRowOrParagraph );
    if (!item || item->type != diStartRow) return NULL;
    return &item->member.row;
}

Referenced by cursor_from_virtual_coords(), cursor_move_line(), draw_table_borders(), editor_handle_message(), ME_ArrowPageUp(), row_from_row_number(), and row_number_from_char_ofs().

◆ para_first_run()

ME_Run * para_first_run ( ME_Paragraph * para )

Definition at line 104 of file para.c.

{
    ME_DisplayItem *di;
 
    for (di = para_get_di( para ); di != para->next_para; di = di->next )
    {
        if (di->type != diRun) continue;
        return &di->member.run;
    }
    ERR( "failed to find run in paragraph\n" );
    return NULL;
}

Referenced by cursor_from_char_ofs(), draw_table_borders(), handle_enter(), handle_wm_char(), itemize_para(), ME_ExtendAnchorSelection(), ME_MoveCursorChars(), ME_MoveCursorWords(), ME_RTFSpecialCharHook(), ME_SelectByType(), ME_SetCursorToStart(), ME_StreamIn(), ME_UpdateSelectionLinkAttribute(), ME_WrapTextParagraph(), para_join(), shape_para(), table_append_row(), table_insert_end_para(), table_insert_row_start_at_para(), table_move_from_row_start(), table_protect_partial_deletion(), and table_select_next_cell_or_append().

◆ para_get_di()

static ME_DisplayItem * para_get_di ( ME_Paragraph * para )

inlinestatic

Definition at line 237 of file editor.h.

{
    return (ME_DisplayItem *)((ptrdiff_t)para - offsetof(ME_DisplayItem, member));
}

Referenced by draw_paragraph(), ME_MakeFirstParagraph(), ME_PrepareParagraphForWrapping(), para_destroy(), para_end_row(), para_first_row(), para_first_run(), para_join(), and para_split().

◆ para_in_table()

BOOL para_in_table ( ME_Paragraph * para )

Definition at line 122 of file para.c.

{
    return para->fmt.wEffects & PFE_TABLE;
}

Referenced by draw_table_borders(), handle_enter(), handle_wm_char(), ME_BeginRow(), ME_RTFSpecialCharHook(), ME_StreamIn(), ME_StreamOutRTF(), table_append_row(), table_handle_tab(), table_protect_partial_deletion(), table_row_end_cell(), table_row_first_cell(), table_select_next_cell_or_append(), and wrap_marked_paras_dc().

◆ para_join()

ME_Paragraph * para_join	(	ME_TextEditor *	editor,
		ME_Paragraph *	para,
		BOOL	use_first_fmt
	)

Definition at line 683 of file para.c.

{
  ME_Paragraph *next = para_next( para );
  ME_Run *end_run, *next_first_run, *tmp_run;
  ME_Cell *cell = NULL;
  int i, end_len;
  CHARFORMAT2W fmt;
  ME_Cursor startCur, endCur;
  ME_String *eol_str;
 
  assert( next && para_next( next ) );
 
  /* Clear any cached para numbering following this paragraph */
  if (para->fmt.wNumbering) para_num_clear_list( editor, para, &para->fmt );
 
  end_run = para_end_run( para );
  next_first_run = para_first_run( next );
 
  end_len = end_run->len;
  eol_str = ME_VSplitString( para->text, end_run->nCharOfs );
  ME_AppendString( para->text, next->text->szData, next->text->nLen );
 
  /* null char format operation to store the original char format for the ENDPARA run */
  ME_InitCharFormat2W(&fmt);
  startCur.para = para;
  startCur.run = end_run;
  endCur.para = next;
  endCur.run = next_first_run;
  startCur.nOffset = endCur.nOffset = 0;
 
  ME_SetCharFormat(editor, &startCur, &endCur, &fmt);
 
  if (!editor->bEmulateVersion10) /* v4.1 */
  {
    /* Remove cell boundary if it is between the end paragraph run and the next
     * paragraph display item. */
    if (para->cell != next->cell) cell = next->cell;
 
    /* Table cell/row properties are always moved over from the removed para. */
    para->nFlags = next->nFlags;
    para->cell = next->cell;
  }
 
  add_undo_split_para( editor, next, eol_str, cell );
 
  if (cell)
  {
    ME_Remove( cell_get_di( cell ) );
    if (cell_prev( cell )) cell_prev( cell )->next_cell = cell_next( cell );
    if (cell_next( cell )) cell_next( cell )->prev_cell = cell_prev( cell );
    ME_DestroyDisplayItem( cell_get_di( cell ) );
  }
 
  if (!use_first_fmt)
  {
    add_undo_set_para_fmt( editor, para );
    para->fmt = next->fmt;
    para->border = next->border;
  }
 
  /* Update selection cursors so they don't point to the removed end
   * paragraph run, and point to the correct paragraph. */
  for (i = 0; i < editor->nCursors; i++)
  {
    if (editor->pCursors[i].run == end_run)
    {
      editor->pCursors[i].run = next_first_run;
      editor->pCursors[i].nOffset = 0;
    }
    else if (editor->pCursors[i].para == next)
      editor->pCursors[i].para = para;
  }
 
  for (tmp_run = next_first_run; tmp_run; tmp_run = run_next( tmp_run ))
  {
    tmp_run->nCharOfs += next->nCharOfs - para->nCharOfs - end_len;
    tmp_run->para = para;
  }
 
  /* Fix up the para's eop_run ptr */
  para->eop_run = next->eop_run;
 
  ME_Remove( run_get_di( end_run ) );
  ME_DestroyDisplayItem( run_get_di( end_run) );
 
  if (editor->last_sel_start_para == next)
    editor->last_sel_start_para = para;
  if (editor->last_sel_end_para == next)
    editor->last_sel_end_para = para;
 
  para->next_para = next->next_para;
  next->next_para->member.para.prev_para = para_get_di( para );
  ME_Remove( para_get_di(next) );
  para_destroy( editor, next );
 
  editor_propagate_char_ofs( para_next( para ), NULL, -end_len );
 
  ME_CheckCharOffsets(editor);
 
  editor->nParagraphs--;
  para_mark_rewrap( editor, para );
  return para;
}

Referenced by ME_InternalDeleteText(), and ME_PlayUndoItem().

◆ para_mark_add()

void para_mark_add	(	ME_TextEditor *	editor,
		ME_Paragraph *	para
	)

Definition at line 99 of file para.c.

{
    wine_rb_put( &editor->marked_paras, &para->nCharOfs, &para->marked_entry );
}

Referenced by ME_MakeFirstParagraph(), and para_mark_rewrap().

◆ para_mark_remove()

void para_mark_remove	(	ME_TextEditor *	editor,
		ME_Paragraph *	para
	)

Definition at line 94 of file para.c.

{
    wine_rb_remove_key( &editor->marked_paras, &para->nCharOfs );
}

Referenced by para_destroy().

◆ para_mark_rewrap()

void para_mark_rewrap	(	ME_TextEditor *	editor,
		ME_Paragraph *	para
	)

Definition at line 26 of file para.c.

{
    para->nFlags |= MEPF_REWRAP;
    para_mark_add( editor, para );
}

Referenced by handle_enter(), ME_InternalDeleteText(), ME_PlayUndoItem(), ME_SetCharFormat(), para_join(), para_mark_rewrap_paras(), para_num_clear_list(), para_set_fmt(), para_split(), run_insert(), run_join(), and run_split().

◆ para_next()

ME_Paragraph * para_next ( ME_Paragraph * para )

Definition at line 57 of file para.c.

{
    if (para->next_para) return &para->next_para->member.para;
    return NULL;
}

Referenced by adjust_para_y(), cursor_from_char_ofs(), cursor_from_virtual_coords(), cursor_move_line(), draw_paragraph(), draw_table_borders(), editor_draw(), editor_first_para(), editor_get_selection_para_fmt(), editor_handle_message(), editor_propagate_char_ofs(), editor_set_selection_para_fmt(), get_unicode_text(), handle_enter(), handle_wm_char(), ITextRange_fnGetText(), ITextSelection_fnGetText(), ME_InternalDeleteText(), ME_MoveCursorChars(), ME_MoveCursorWords(), ME_RTFParAttrHook(), ME_RTFSpecialCharHook(), ME_StreamIn(), ME_UpdateSelectionLinkAttribute(), para_end_row(), para_join(), para_mark_rewrap_paras(), para_split(), pixel_pos_in_table_row(), range_GetChar(), row_from_row_number(), row_number_from_char_ofs(), table_append_row(), table_insert_row_start_at_para(), table_move_from_row_start(), table_protect_partial_deletion(), table_row_end(), table_row_first_cell(), table_select_next_cell_or_append(), and wrap_marked_paras_dc().

◆ para_num_clear()

void para_num_clear ( struct para_num * pn )

Definition at line 436 of file para.c.

{
    if (pn->style)
    {
        ME_ReleaseStyle( pn->style );
        pn->style = NULL;
    }
    ME_DestroyString( pn->text );
    pn->text = NULL;
}

Referenced by para_destroy(), and para_num_clear_list().

◆ para_num_init()

void para_num_init	(	ME_Context *	c,
		ME_Paragraph *	para
	)

Definition at line 392 of file para.c.

{
    ME_Style *style;
    CHARFORMAT2W cf;
    SIZE sz;
 
    if (!para->fmt.wNumbering) return;
    if (para->para_num.style && para->para_num.text) return;
 
    if (!para->para_num.style)
    {
        style = para->eop_run->style;
 
        if (para->fmt.wNumbering == PFN_BULLET)
        {
            cf.cbSize = sizeof(cf);
            cf.dwMask = CFM_FACE | CFM_CHARSET;
            lstrcpyW( cf.szFaceName, L"Symbol" );
            cf.bCharSet = SYMBOL_CHARSET;
            style = ME_ApplyStyle( c->editor, style, &cf );
        }
        else
        {
            ME_AddRefStyle( style );
        }
 
        para->para_num.style = style;
    }
 
    if (!para->para_num.text)
    {
        if (para->fmt.wNumbering != PFN_BULLET)
            para->para_num.text = para_num_get_str( para, para_num_get_num( para ) );
        else
            para->para_num.text = ME_MakeStringConst( L"\x00b7", 1 );
    }
 
    select_style( c, para->para_num.style );
    GetTextExtentPointW( c->hDC, para->para_num.text->szData, para->para_num.text->nLen, &sz );
    para->para_num.width = sz.cx;
    GetTextExtentPointW( c->hDC, L" ", 1, &sz );
    para->para_num.width += sz.cx;
}

Referenced by ME_WrapTextParagraph().

◆ para_prev()

ME_Paragraph * para_prev ( ME_Paragraph * para )

Definition at line 63 of file para.c.

{
    if (para->prev_para && para->prev_para->type == diParagraph) return &para->prev_para->member.para;
    return NULL;
}

Referenced by cursor_from_virtual_coords(), cursor_move_line(), editor_get_selection_paras(), editor_handle_message(), handle_enter(), handle_wm_char(), ME_ArrowPageDown(), ME_GetTextW(), ME_InsertTextFromCursor(), ME_InvalidateSelection(), ME_MoveCursorChars(), ME_MoveCursorWords(), ME_SetCursorToEnd(), ME_UpdateSelectionLinkAttribute(), para_split(), pixel_pos_in_table_row(), stream_out_para_props(), table_insert_row_end(), table_insert_row_start(), table_outer_para(), table_protect_partial_deletion(), table_row_end_cell(), table_row_start(), and table_select_next_cell_or_append().

◆ para_range_invalidate()

void para_range_invalidate	(	ME_TextEditor *	editor,
		ME_Paragraph *	start_para,
		ME_Paragraph *	last_para
	)

Definition at line 1102 of file wrap.c.

{
  RECT rc;
  int ofs;
 
  rc = editor->rcFormat;
  ofs = editor->vert_si.nPos;
 
  if (start_para)
  {
    start_para = table_outer_para( start_para );
    last_para = table_outer_para( last_para );
    rc.top += start_para->pt.y - ofs;
  } else {
    rc.top += editor->nTotalLength - ofs;
  }
  if (editor->nTotalLength < editor->nLastTotalLength)
    rc.bottom = editor->rcFormat.top + editor->nLastTotalLength - ofs;
  else
    rc.bottom = editor->rcFormat.top + last_para->pt.y + last_para->nHeight - ofs;
  ITextHost_TxInvalidateRect(editor->texthost, &rc, TRUE);
}

Referenced by ME_InvalidateSelection(), and wrap_marked_paras_dc().

◆ para_split()

ME_Paragraph * para_split	(	ME_TextEditor *	editor,
		ME_Run *	run,
		ME_Style *	style,
		const WCHAR *	eol_str,
		int	eol_len,
		int	paraFlags
	)

Definition at line 540 of file para.c.

{
  ME_Paragraph *new_para = para_create( editor ), *old_para, *next_para;
  ME_Run *end_run, *next_run;
  int ofs, i;
  int run_flags = MERF_ENDPARA;
 
  if (!editor->bEmulateVersion10) /* v4.1 */
  {
    /* At most 1 of MEPF_CELL, MEPF_ROWSTART, or MEPF_ROWEND should be set. */
    assert( !(paraFlags & ~(MEPF_CELL | MEPF_ROWSTART | MEPF_ROWEND)) );
    assert( !(paraFlags & (paraFlags-1)) );
    if (paraFlags == MEPF_CELL)
        run_flags |= MERF_ENDCELL;
    else if (paraFlags == MEPF_ROWSTART)
      run_flags |= MERF_TABLESTART | MERF_HIDDEN;
  }
  else /* v1.0 - v3.0 */
    assert( !(paraFlags & (MEPF_CELL |MEPF_ROWSTART | MEPF_ROWEND)) );
 
  old_para = run->para;
  assert( old_para->fmt.cbSize == sizeof(PARAFORMAT2) );
 
  /* Clear any cached para numbering following this paragraph */
  if (old_para->fmt.wNumbering)
      para_num_clear_list( editor, old_para, &old_para->fmt );
 
  new_para->text = ME_VSplitString( old_para->text, run->nCharOfs );
 
  end_run = run_create( style, run_flags );
  ofs = end_run->nCharOfs = run->nCharOfs;
  end_run->len = eol_len;
  end_run->para = run->para;
  ME_AppendString( old_para->text, eol_str, eol_len );
  next_para = &old_para->next_para->member.para;
 
  add_undo_join_paras( editor, old_para->nCharOfs + ofs );
 
  /* Update selection cursors to point to the correct paragraph. */
  for (i = 0; i < editor->nCursors; i++)
  {
    if (editor->pCursors[i].para == old_para &&
        run->nCharOfs <= editor->pCursors[i].run->nCharOfs)
    {
      editor->pCursors[i].para = new_para;
    }
  }
 
  /* the new paragraph will have a different starting offset, so update its runs */
  for (next_run = run; next_run; next_run = run_next( next_run ))
  {
    next_run->nCharOfs -= ofs;
    next_run->para = new_para;
  }
 
  new_para->nCharOfs = old_para->nCharOfs + ofs;
  new_para->nCharOfs += eol_len;
  new_para->nFlags = 0;
  para_mark_rewrap( editor, new_para );
 
  /* FIXME initialize format style and call ME_SetParaFormat blah blah */
  new_para->fmt = old_para->fmt;
  new_para->border = old_para->border;
 
  /* insert paragraph into paragraph double linked list */
  new_para->prev_para = para_get_di( old_para );
  new_para->next_para = para_get_di( next_para );
  old_para->next_para = para_get_di( new_para );
  next_para->prev_para = para_get_di( new_para );
 
  /* insert end run of the old paragraph, and new paragraph, into DI double linked list */
  ME_InsertBefore( run_get_di( run ), para_get_di( new_para ) );
  ME_InsertBefore( para_get_di( new_para ), run_get_di( end_run ) );
 
  /* Fix up the paras' eop_run ptrs */
  new_para->eop_run = old_para->eop_run;
  old_para->eop_run = end_run;
 
  if (!editor->bEmulateVersion10) /* v4.1 */
  {
    if (paraFlags & (MEPF_ROWSTART | MEPF_CELL))
    {
      ME_Cell *cell = cell_create();
      ME_InsertBefore( para_get_di( new_para ), cell_get_di( cell ) );
      new_para->cell = cell;
      cell->next_cell = NULL;
      if (paraFlags & MEPF_ROWSTART)
      {
        old_para->nFlags |= MEPF_ROWSTART;
        cell->prev_cell = NULL;
        cell->parent_cell = old_para->cell;
        if (para_cell( old_para ))
          cell->nNestingLevel = para_cell( old_para )->nNestingLevel + 1;
        else
          cell->nNestingLevel = 1;
      }
      else
      {
        cell->prev_cell = old_para->cell;
        cell_prev( cell )->next_cell = cell;
        assert( old_para->nFlags & MEPF_CELL );
        assert( !(old_para->nFlags & MEPF_ROWSTART) );
        cell->nNestingLevel = cell_prev( cell )->nNestingLevel;
        cell->parent_cell = cell_prev( cell )->parent_cell;
      }
    }
    else if (paraFlags & MEPF_ROWEND)
    {
      old_para->nFlags |= MEPF_ROWEND;
      old_para->cell = old_para->cell->parent_cell;
      new_para->cell = old_para->cell;
      assert( para_prev( old_para )->nFlags & MEPF_CELL );
      assert( !(para_prev( old_para )->nFlags & MEPF_ROWSTART) );
      if (new_para->cell != para_next( new_para )->cell
          && para_next( new_para )->cell
          && !cell_prev( para_next( new_para )->cell ))
      {
        /* Row starts just after the row that was ended. */
        new_para->nFlags |= MEPF_ROWSTART;
      }
    }
    else new_para->cell = old_para->cell;
 
    table_update_flags( old_para );
    table_update_flags( new_para );
  }
 
  /* force rewrap of the */
  if (old_para->prev_para->type == diParagraph)
    para_mark_rewrap( editor, &old_para->prev_para->member.para );
 
  para_mark_rewrap( editor, &new_para->prev_para->member.para );
 
  /* we've added the end run, so we need to modify nCharOfs in the next paragraphs */
  editor_propagate_char_ofs( next_para, NULL, eol_len );
  editor->nParagraphs++;
 
  return new_para;
}

Referenced by ME_InsertTextFromCursor(), ME_PlayUndoItem(), and table_insert_end_para().

◆ release_typelib()

void release_typelib ( void )

Definition at line 159 of file apps.c.

{
    unsigned i;
 
    for (i = 0; i < ARRAY_SIZE(typeinfo); i++)
        if (typeinfo[i])
            ITypeInfo_Release(typeinfo[i]);
 
    if (typelib)
        ITypeLib_Release(typelib);
}

◆ richole_release_children()

void richole_release_children ( struct text_services * services )

Definition at line 5853 of file richole.c.

{
    ITextRangeImpl *range;
    IOleClientSiteImpl *site;
 
    if (services->text_selection)
    {
        services->text_selection->services = NULL;
        ITextSelection_Release( &services->text_selection->ITextSelection_iface );
    }
 
    LIST_FOR_EACH_ENTRY( range, &services->rangelist, ITextRangeImpl, child.entry )
        range->child.reole = NULL;
 
    LIST_FOR_EACH_ENTRY( site, &services->clientsites, IOleClientSiteImpl, child.entry )
        site->child.reole = NULL;
}

Referenced by ITextServicesImpl_Release().

◆ row_end_cursor()

void row_end_cursor	(	ME_Row *	row,
		ME_Cursor *	cursor,
		BOOL	include_eop
	)

Definition at line 92 of file row.c.

{
    ME_DisplayItem *item, *run;
 
    item = ME_FindItemFwd( row_get_di( row ), diStartRowOrParagraphOrEnd );
    run = ME_FindItemBack( item, diRun );
    cursor->run = &run->member.run;
    cursor->para = cursor->run->para;
    cursor->nOffset = (item->type == diStartRow || include_eop) ? cursor->run->len : 0;
}

Referenced by editor_handle_message(), ME_ArrowEnd(), ME_ExtendAnchorSelection(), ME_SelectByType(), and row_number_from_char_ofs().

◆ row_first_cursor()

void row_first_cursor	(	ME_Row *	row,
		ME_Cursor *	cursor
	)

Definition at line 82 of file row.c.

{
    ME_DisplayItem *item;
 
    item = ME_FindItemFwd( row_get_di( row ), diRun );
    cursor->run = &item->member.run;
    cursor->para = cursor->run->para;
    cursor->nOffset = 0;
}

Referenced by editor_handle_message(), ME_ArrowHome(), ME_ExtendAnchorSelection(), ME_SelectByType(), and row_para().

◆ row_first_run()

ME_Run * row_first_run ( ME_Row * row )

Definition at line 54 of file row.c.

{
    ME_DisplayItem *item;
 
    item = ME_FindItemFwd( row_get_di( row ), diRunOrStartRow );
    assert( item->type == diRun );
    return &item->member.run;
}

Referenced by row_cursor().

◆ row_from_cursor()

ME_Row * row_from_cursor ( ME_Cursor * cursor )

Definition at line 74 of file row.c.

{
    ME_DisplayItem *item;
 
    item = ME_FindItemBack( run_get_di( cursor->run ), diStartRow );
    return &item->member.row;
}

Referenced by cursor_coords(), cursor_move_line(), draw_run(), editor_ensure_visible(), editor_handle_message(), ME_ArrowEnd(), ME_ArrowHome(), ME_ArrowPageDown(), ME_ArrowPageUp(), ME_ExtendAnchorSelection(), and ME_SelectByType().

◆ row_from_row_number()

ME_Row * row_from_row_number	(	ME_TextEditor *	editor,
		int	row_num
	)

Definition at line 111 of file row.c.

{
    ME_Paragraph *para = editor_first_para( editor );
    ME_Row *row;
    int count = 0;
 
    while (para_next( para ) && count + para->nRows <= row_num)
    {
        count += para->nRows;
        para = para_next( para );
    }
    if (!para_next( para )) return NULL;
 
    for (row = para_first_row( para ); row && count < row_num; count++)
        row = row_next( row );
 
    return row;
}

Referenced by editor_handle_message().

◆ row_get_di()

static ME_DisplayItem * row_get_di ( ME_Row * row )

inlinestatic

Definition at line 126 of file editor.h.

{
    return (ME_DisplayItem *)((ptrdiff_t)row - offsetof(ME_DisplayItem, member));
}

Referenced by ME_InsertRowStart(), row_end_cursor(), row_first_cursor(), row_first_run(), row_next(), row_next_all_paras(), and row_prev_all_paras().

◆ row_next()

ME_Row * row_next ( ME_Row * row )

Definition at line 27 of file row.c.

{
    ME_DisplayItem *item;
 
    item = ME_FindItemFwd( row_get_di( row ), diStartRowOrParagraphOrEnd );
    if (!item || item->type != diStartRow) return NULL;
    return &item->member.row;
}

Referenced by cursor_from_virtual_coords(), editor_handle_message(), row_from_row_number(), and row_number_from_char_ofs().

◆ row_next_all_paras()

ME_Row * row_next_all_paras ( ME_Row * row )

Definition at line 36 of file row.c.

{
    ME_DisplayItem *item;
 
    item = ME_FindItemFwd( row_get_di( row ), diStartRow );
    if (!item) return NULL;
    return &item->member.row;
}

Referenced by cursor_move_line(), and ME_ArrowPageDown().

◆ row_next_run()

ME_Run * row_next_run	(	ME_Row *	row,
		ME_Run *	run
	)

Definition at line 63 of file row.c.

{
    ME_DisplayItem *item;
 
    assert( row == &ME_FindItemBack( run_get_di( run ), diStartRow )->member.row );
 
    item = ME_FindItemFwd( run_get_di( run ), diRunOrStartRow );
    if (!item || item->type == diStartRow) return NULL;
    return &item->member.run;
}

Referenced by editor_handle_message(), and row_cursor().

◆ row_number_from_char_ofs()

int row_number_from_char_ofs	(	ME_TextEditor *	editor,
		int	ofs
	)

Definition at line 131 of file row.c.

{
    ME_Paragraph *para = editor_first_para( editor );
    ME_Row *row;
    ME_Cursor cursor;
    int row_num = 0;
 
    while (para_next( para ) && para_next( para )->nCharOfs <= ofs)
    {
        row_num += para->nRows;
        para = para_next( para );
    }
 
    if (para_next( para ))
    {
        for (row = para_first_row( para ); row; row = row_next( row ))
        {
            row_end_cursor( row, &cursor, TRUE );
            if (ME_GetCursorOfs( &cursor ) > ofs ) break;
            row_num++;
        }
    }
 
    return row_num;
}

Referenced by editor_handle_message().

◆ row_para()

ME_Paragraph * row_para ( ME_Row * row )

Definition at line 103 of file row.c.

{
    ME_Cursor cursor;
 
    row_first_cursor( row, &cursor );
    return cursor.para;
}

Referenced by cursor_move_line(), ME_ArrowPageDown(), and ME_ArrowPageUp().

◆ row_prev_all_paras()

ME_Row * row_prev_all_paras ( ME_Row * row )

Definition at line 45 of file row.c.

{
    ME_DisplayItem *item;
 
    item = ME_FindItemBack( row_get_di( row ), diStartRow );
    if (!item) return NULL;
    return &item->member.row;
}

Referenced by cursor_move_line(), and ME_ArrowPageUp().

◆ run_char_ofs()

int run_char_ofs	(	ME_Run *	run,
		int	ofs
	)

Definition at line 228 of file run.c.

{
    return run->para->nCharOfs + run->nCharOfs + ofs;
}

Referenced by draw_run().

◆ run_create()

ME_Run * run_create	(	ME_Style *	s,
		int	nFlags
	)

Definition at line 343 of file run.c.

{
    ME_DisplayItem *item = ME_MakeDI( diRun );
    ME_Run *run = &item->member.run;
 
    if (!item) return NULL;
 
    ME_AddRefStyle( s );
    run->style = s;
    run->reobj = NULL;
    run->nFlags = flags;
    run->nCharOfs = -1;
    run->len = 0;
    run->para = NULL;
    run->num_glyphs = 0;
    run->max_glyphs = 0;
    run->glyphs = NULL;
    run->vis_attrs = NULL;
    run->advances = NULL;
    run->offsets = NULL;
    run->max_clusters = 0;
    run->clusters = NULL;
    return run;
}

Referenced by ME_MakeFirstParagraph(), para_split(), run_insert(), and run_split().

◆ run_get_di()

static ME_DisplayItem * run_get_di ( ME_Run * run )

inlinestatic

Definition at line 163 of file editor.h.

{
    return (ME_DisplayItem *)((ptrdiff_t)run - offsetof(ME_DisplayItem, member));
}

Referenced by cursor_next_run(), cursor_prev_run(), ME_InsertRowStart(), ME_InternalDeleteText(), ME_MakeFirstParagraph(), para_join(), para_split(), row_from_cursor(), row_next_run(), run_insert(), run_join(), and run_split().

◆ run_insert()

ME_Run * run_insert	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor,
		ME_Style *	style,
		const WCHAR *	str,
		int	len,
		int	flags
	)

Definition at line 375 of file run.c.

{
  ME_Run *insert_before = cursor->run, *run, *prev;
 
  if (cursor->nOffset)
  {
    if (cursor->nOffset == insert_before->len)
    {
      insert_before = run_next_all_paras( insert_before );
      if (!insert_before) insert_before = cursor->run; /* Always insert before the final eop run */
    }
    else
    {
      run_split( editor, cursor );
      insert_before = cursor->run;
    }
  }
 
  add_undo_delete_run( editor, insert_before->para->nCharOfs + insert_before->nCharOfs, len );
 
  run = run_create( style, flags );
  run->nCharOfs = insert_before->nCharOfs;
  run->len = len;
  run->para = insert_before->para;
  ME_InsertString( run->para->text, run->nCharOfs, str, len );
  ME_InsertBefore( run_get_di( insert_before ), run_get_di( run ) );
  TRACE("Shift length:%d\n", len);
  editor_propagate_char_ofs( NULL, insert_before, len );
  para_mark_rewrap( editor, insert_before->para );
 
  /* Move any cursors that were at the end of the previous run to the end of the inserted run */
  prev = run_prev_all_paras( run );
  if (prev)
  {
    int i;
 
    for (i = 0; i < editor->nCursors; i++)
    {
      if (editor->pCursors[i].run == prev &&
          editor->pCursors[i].nOffset == prev->len)
      {
        editor->pCursors[i].run = run;
        editor->pCursors[i].nOffset = len;
      }
    }
  }
 
  return run;
}

Referenced by ME_InsertEndRowFromCursor(), ME_InsertOLEFromCursor(), ME_InsertTextFromCursor(), and ME_PlayUndoItem().

◆ run_join()

void run_join	(	ME_TextEditor *	editor,
		ME_Run *	run
	)

Definition at line 273 of file run.c.

{
  ME_Run *next = run_next( run );
  int i;
 
  assert( run );
  assert( run->nCharOfs != -1 );
  para_mark_rewrap( editor, run->para );
 
  /* Update all cursors so that they don't contain the soon deleted run */
  for (i = 0; i < editor->nCursors; i++)
  {
    if (editor->pCursors[i].run == next)
    {
      editor->pCursors[i].run = run;
      editor->pCursors[i].nOffset += run->len;
    }
  }
 
  run->len += next->len;
  ME_Remove( run_get_di( next ) );
  ME_DestroyDisplayItem( run_get_di( next ) );
  ME_UpdateRunFlags( editor, run );
  ME_CheckCharOffsets( editor );
}

Referenced by ME_PrepareParagraphForWrapping().

◆ run_next()

ME_Run * run_next ( ME_Run * run )

Definition at line 68 of file run.c.

{
    ME_Cursor cursor;
 
    cursor.run = run;
    cursor.para = run->para;
    cursor.nOffset = 0;
 
    if (cursor_next_run( &cursor, FALSE ))
        return cursor.run;
 
    return NULL;
}

Referenced by cursor_from_char_ofs(), editor_propagate_char_ofs(), itemize_para(), layout_row(), link_notify(), ME_InsertRowStart(), ME_InsertTextFromCursor(), ME_InternalDeleteText(), ME_MoveCursorChars(), ME_MoveCursorWords(), ME_WrapHandleRun(), para_join(), para_split(), run_join(), shape_para(), table_protect_partial_deletion(), and table_select_next_cell_or_append().

◆ run_next_all_paras()

ME_Run * run_next_all_paras ( ME_Run * run )

Definition at line 96 of file run.c.

{
    ME_Cursor cursor;
 
    cursor.run = run;
    cursor.para = run->para;
    cursor.nOffset = 0;
 
    if (cursor_next_run( &cursor, TRUE ))
        return cursor.run;
 
    return NULL;
}

Referenced by ME_FindText(), ME_GetCharFormat(), ME_GetTextW(), ME_SetCharFormat(), ME_StreamOutText(), ME_UpdateLinkAttribute(), run_insert(), stream_out_font_and_colour_tbls(), and table_select_next_cell_or_append().

◆ run_prev()

ME_Run * run_prev ( ME_Run * run )

Definition at line 82 of file run.c.

{
    ME_Cursor cursor;
 
    cursor.run = run;
    cursor.para = run->para;
    cursor.nOffset = 0;
 
    if (cursor_prev_run( &cursor, FALSE ))
        return cursor.run;
 
    return NULL;
}

Referenced by cursor_coords(), layout_row(), link_notify(), ME_GetCharFormat(), ME_InsertRowStart(), ME_InsertTextFromCursor(), ME_MaximizeSplit(), ME_MoveCursorChars(), ME_MoveCursorWords(), ME_WrapHandleRun(), style_get_insert_style(), and table_handle_tab().

◆ run_prev_all_paras()

ME_Run * run_prev_all_paras ( ME_Run * run )

Definition at line 110 of file run.c.

{
    ME_Cursor cursor;
 
    cursor.run = run;
    cursor.para = run->para;
    cursor.nOffset = 0;
 
    if (cursor_prev_run( &cursor, TRUE ))
        return cursor.run;
 
    return NULL;
}

Referenced by editor_handle_message(), ME_FindText(), ME_GetCharFormat(), ME_InsertOLEFromCursor(), ME_InternalDeleteText(), and run_insert().

◆ run_split()

ME_Run * run_split	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor
	)

Definition at line 305 of file run.c.

{
    ME_Run *run = cursor->run, *new_run;
    int i;
    int nOffset = cursor->nOffset;
 
    assert( !(run->nFlags & MERF_NONTEXT) );
 
    new_run = run_create( run->style, run->nFlags & MERF_SPLITMASK );
    new_run->nCharOfs = run->nCharOfs + nOffset;
    new_run->len = run->len - nOffset;
    new_run->para = run->para;
    run->len = nOffset;
    cursor->run = new_run;
    cursor->nOffset = 0;
 
    ME_InsertBefore( run_get_di( run )->next, run_get_di( new_run ) );
 
    ME_UpdateRunFlags( editor, run );
    ME_UpdateRunFlags( editor, new_run );
    for (i = 0; i < editor->nCursors; i++)
    {
        if (editor->pCursors[i].run == run &&
            editor->pCursors[i].nOffset >= nOffset)
        {
            editor->pCursors[i].run = new_run;
            editor->pCursors[i].nOffset -= nOffset;
        }
    }
    para_mark_rewrap( editor, run->para );
    return run;
}

Referenced by itemize_para(), ME_InsertTextFromCursor(), ME_PlayUndoItem(), ME_SetCharFormat(), run_insert(), split_run_extents(), and table_insert_end_para().

◆ scroll_abs()

void scroll_abs	(	ME_TextEditor *	editor,
		int	x,
		int	y,
		BOOL	notify
	)

Definition at line 1087 of file paint.c.

{
  int scrollX = 0, scrollY = 0;
 
  if (editor->horz_si.nPos != x) {
    x = min(x, editor->horz_si.nMax);
    x = max(x, editor->horz_si.nMin);
    scrollX = editor->horz_si.nPos - x;
    editor->horz_si.nPos = x;
    set_scroll_range_pos( editor, SB_HORZ, &editor->horz_si, FALSE, notify );
  }
 
  if (editor->vert_si.nPos != y) {
    y = min(y, editor->vert_si.nMax - (int)editor->vert_si.nPage);
    y = max(y, editor->vert_si.nMin);
    scrollY = editor->vert_si.nPos - y;
    editor->vert_si.nPos = y;
    set_scroll_range_pos( editor, SB_VERT, &editor->vert_si, FALSE, notify );
  }
 
  if (abs(scrollX) > editor->sizeWindow.cx || abs(scrollY) > editor->sizeWindow.cy)
    ITextHost_TxInvalidateRect(editor->texthost, NULL, TRUE);
  else
    ITextHost_TxScrollWindowEx(editor->texthost, scrollX, scrollY,
                               &editor->rcFormat, &editor->rcFormat,
                               NULL, NULL, SW_INVALIDATE);
  ME_UpdateScrollBar(editor);
  ME_Repaint(editor);
}

Referenced by editor_ensure_visible(), editor_handle_message(), ITextRange_fnScrollIntoView(), scroll_h_abs(), and scroll_v_abs().

◆ scroll_h_abs()

void scroll_h_abs	(	ME_TextEditor *	editor,
		int	x,
		BOOL	notify
	)

Definition at line 1117 of file paint.c.

{
    scroll_abs( editor, x, editor->vert_si.nPos, notify );
}

Referenced by editor_ensure_visible(), editor_handle_message(), ME_ScrollLeft(), ME_ScrollRight(), and ME_UpdateScrollBar().

◆ scroll_v_abs()

void scroll_v_abs	(	ME_TextEditor *	editor,
		int	y,
		BOOL	notify
	)

Definition at line 1122 of file paint.c.

{
    scroll_abs( editor, editor->horz_si.nPos, y, notify );
}

Referenced by editor_handle_message(), ME_ScrollDown(), ME_ScrollUp(), and ME_UpdateScrollBar().

◆ select_style()

void select_style	(	ME_Context *	c,
		ME_Style *	s
	)

Definition at line 369 of file style.c.

{
    HFONT old_font;
    LOGFONTW lf;
    int i, empty, age = 0x7FFFFFFF;
    ME_FontCacheItem *item;
 
    if (c->current_style == s) return;
 
    if (s)
    {
        ME_LogFontFromStyle( c, &lf, s );
 
        for (i = 0; i < HFONT_CACHE_SIZE; i++)
            c->editor->pFontCache[i].nAge++;
        for (i = 0, empty = -1, age = 0; i < HFONT_CACHE_SIZE; i++)
        {
            item = &c->editor->pFontCache[i];
            if (!item->nRefs)
            {
                if (item->nAge > age)
                {
                    empty = i;
                    age = item->nAge;
                }
            }
 
            if (item->hFont && ME_IsFontEqual( &item->lfSpecs, &lf ))
                break;
        }
 
        if (i < HFONT_CACHE_SIZE) /* found */
        {
            item = &c->editor->pFontCache[i];
            TRACE_(richedit_style)( "font reused %d\n", i );
            item->nRefs++;
        }
        else
        {
            assert(empty != -1);
            item = &c->editor->pFontCache[empty];
            if (item->hFont)
            {
                TRACE_(richedit_style)( "font deleted %d\n", empty );
                DeleteObject(item->hFont);
                item->hFont = NULL;
            }
            item->hFont = CreateFontIndirectW( &lf );
            TRACE_(richedit_style)( "font created %d\n", empty );
            item->nRefs = 1;
            item->lfSpecs = lf;
        }
        s->font_cache = item;
        old_font = SelectObject( c->hDC, item->hFont );
        GetTextMetricsW( c->hDC, &s->tm );
        if (!c->orig_font) c->orig_font = old_font;
    }
    else
    {
        SelectObject( c->hDC, c->orig_font );
        c->orig_font = NULL;
    }
 
    if (c->current_style)
    {
        release_font_cache( c->current_style->font_cache );
        c->current_style->font_cache = NULL;
    }
    c->current_style = s;
 
    return;
}

Referenced by draw_para_number(), draw_space(), draw_text_with_style(), ME_CharFromPointContext(), ME_DestroyContext(), ME_GetTextExtent(), para_num_init(), and shape_run().

◆ set_selection()

int set_selection	(	ME_TextEditor *	editor,
		int	to,
		int	from
	)

Definition at line 2146 of file editor.c.

{
    int end;
 
    TRACE("%d - %d\n", to, from );
 
    if (!editor->bHideSelection) ME_InvalidateSelection( editor );
    end = set_selection_cursors( editor, to, from );
    if (!editor->bHideSelection) ME_InvalidateSelection( editor );
    update_caret( editor );
    ME_SendSelChange( editor );
 
    return end;
}

◆ set_selection_cursors()

int set_selection_cursors	(	ME_TextEditor *	editor,
		int	from,
		int	to
	)

Definition at line 132 of file caret.c.

{
  int selectionEnd = 0;
  const int len = ME_GetTextLength(editor);
 
  /* all negative values are effectively the same */
  if (from < 0)
    from = -1;
  if (to < 0)
    to = -1;
 
  /* select all */
  if (from == 0 && to == -1)
  {
    ME_SetCursorToStart(editor, &editor->pCursors[1]);
    ME_SetCursorToEnd(editor, &editor->pCursors[0], TRUE);
    return len + 1;
  }
 
  /* if both values are equal and also out of bound, that means to */
  /* put the selection at the end of the text */
  if ((from == to) && (to < 0 || to > len))
  {
    selectionEnd = 1;
  }
  else
  {
    /* if from is negative and to is positive then selection is */
    /* deselected and caret moved to end of the current selection */
    if (from < 0)
    {
      int start, end;
      ME_GetSelectionOfs(editor, &start, &end);
      if (start != end)
      {
          if (end > len)
          {
              editor->pCursors[0].nOffset = 0;
              end --;
          }
          editor->pCursors[1] = editor->pCursors[0];
      }
      return end;
    }
 
    /* adjust to if it's a negative value */
    if (to < 0)
      to = len + 1;
 
    /* flip from and to if they are reversed */
    if (from>to)
    {
      int tmp = from;
      from = to;
      to = tmp;
    }
 
    /* after fiddling with the values, we find from > len && to > len */
    if (from > len)
      selectionEnd = 1;
    /* special case with to too big */
    else if (to > len)
      to = len + 1;
  }
 
  if (selectionEnd)
  {
    ME_SetCursorToEnd(editor, &editor->pCursors[0], FALSE);
    editor->pCursors[1] = editor->pCursors[0];
    return len;
  }
 
  cursor_from_char_ofs( editor, from, &editor->pCursors[1] );
  editor->pCursors[0] = editor->pCursors[1];
  ME_MoveCursorChars(editor, &editor->pCursors[0], to - from, FALSE);
  /* Selection is not allowed in the middle of an end paragraph run. */
  if (editor->pCursors[1].run->nFlags & MERF_ENDPARA)
    editor->pCursors[1].nOffset = 0;
  if (editor->pCursors[0].run->nFlags & MERF_ENDPARA)
  {
    if (to > len)
      editor->pCursors[0].nOffset = editor->pCursors[0].run->len;
    else
      editor->pCursors[0].nOffset = 0;
  }
  return to;
}

Referenced by editor_handle_message(), fnTextSrv_TxSetText(), ME_StreamIn(), and set_selection().

◆ show_caret()

void show_caret ( ME_TextEditor * ed )

Definition at line 261 of file caret.c.

{
  ITextHost_TxShowCaret(editor->texthost, TRUE);
  editor->caret_hidden = FALSE;
}

Referenced by update_caret().

◆ style_get_insert_style()

ME_Style * style_get_insert_style	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor
	)

Definition at line 476 of file style.c.

{
    ME_Style *style;
    ME_Cursor *from, *to;
    ME_Run *prev;
 
    if (ME_IsSelection( editor ))
    {
        ME_GetSelection( editor, &from, &to );
        style = from->run->style;
    }
    else if (editor->pBuffer->pCharStyle)
        style = editor->pBuffer->pCharStyle;
    else if (!cursor->nOffset && (prev = run_prev( cursor->run )))
        style = prev->style;
    else
        style = cursor->run->style;
 
    ME_AddRefStyle( style );
    return style;
}

Referenced by editor_handle_message(), handle_enter(), handle_wm_char(), ITextRange_fnSetText(), ME_GetSelectionInsertStyle(), ME_InsertEndRowFromCursor(), ME_InsertOLEFromCursor(), ME_SetSelectionCharFormat(), and table_insert_end_para().

◆ table_append_row()

ME_Paragraph * table_append_row	(	ME_TextEditor *	editor,
		ME_Paragraph *	table_row
	)

Definition at line 327 of file table.c.

{
  WCHAR endl = '\r', tab = '\t';
  ME_Run *run;
  int i;
 
  if (!editor->bEmulateVersion10) /* v4.1 */
  {
    ME_Cell *new_cell, *cell;
    ME_Paragraph *para, *prev_table_end, *new_row_start;
 
    cell = table_row_first_cell( table_row );
    prev_table_end = table_row_end( table_row );
    para = para_next( prev_table_end );
    run = para_first_run( para );
    editor->pCursors[0].para = para;
    editor->pCursors[0].run = run;
    editor->pCursors[0].nOffset = 0;
    editor->pCursors[1] = editor->pCursors[0];
    new_row_start = table_insert_row_start( editor, editor->pCursors );
    new_cell = table_row_first_cell( new_row_start );
    /* Copy cell properties */
    new_cell->nRightBoundary = cell->nRightBoundary;
    new_cell->border = cell->border;
    while (cell_next( cell ))
    {
      cell = cell_next( cell );
      para = table_insert_cell( editor, editor->pCursors );
      new_cell = para_cell( para );
      /* Copy cell properties */
      new_cell->nRightBoundary = cell->nRightBoundary;
      new_cell->border = cell->border;
    };
    para = table_insert_row_end( editor, editor->pCursors );
    para->fmt = prev_table_end->fmt;
    /* return the table row start for the inserted paragraph */
    return new_row_start;
  }
  else /* v1.0 - 3.0 */
  {
    run = para_end_run( table_row );
    assert( para_in_table( table_row ) );
    editor->pCursors[0].para = table_row;
    editor->pCursors[0].run = run;
    editor->pCursors[0].nOffset = 0;
    editor->pCursors[1] = editor->pCursors[0];
    ME_InsertTextFromCursor( editor, 0, &endl, 1, run->style );
    run = editor->pCursors[0].run;
    for (i = 0; i < table_row->fmt.cTabCount; i++)
      ME_InsertTextFromCursor( editor, 0, &tab, 1, run->style );
 
    return para_next( table_row );
  }
}

Referenced by handle_enter(), and table_select_next_cell_or_append().

◆ table_handle_tab()

void table_handle_tab	(	ME_TextEditor *	editor,
		BOOL	selected_row
	)

Definition at line 473 of file table.c.

{
  /* FIXME: Shift tab should move to the previous cell. */
  ME_Cursor fromCursor, toCursor;
  ME_InvalidateSelection(editor);
  {
    int from, to;
    from = ME_GetCursorOfs(&editor->pCursors[0]);
    to = ME_GetCursorOfs(&editor->pCursors[1]);
    if (from <= to)
    {
      fromCursor = editor->pCursors[0];
      toCursor = editor->pCursors[1];
    }
    else
    {
      fromCursor = editor->pCursors[1];
      toCursor = editor->pCursors[0];
    }
  }
  if (!editor->bEmulateVersion10) /* v4.1 */
  {
    if (!para_in_table( toCursor.para ))
    {
      editor->pCursors[0] = toCursor;
      editor->pCursors[1] = toCursor;
    }
    else table_select_next_cell_or_append( editor, toCursor.run );
  }
  else /* v1.0 - 3.0 */
  {
    if (!para_in_table( fromCursor.para ))
    {
      editor->pCursors[0] = fromCursor;
      editor->pCursors[1] = fromCursor;
      /* FIXME: For some reason the caret is shown at the start of the
       *        previous paragraph in v1.0 to v3.0 */
    }
    else if ((selected_row || !para_in_table( toCursor.para )))
      table_select_next_cell_or_append( editor, fromCursor.run );
    else
    {
      ME_Run *run = run_prev( toCursor.run );
 
      if (ME_IsSelection(editor) && !toCursor.nOffset && run && run->nFlags & MERF_TAB)
        table_select_next_cell_or_append( editor, run );
      else
        table_select_next_cell_or_append( editor, toCursor.run );
    }
  }
  ME_InvalidateSelection(editor);
  ME_Repaint(editor);
  update_caret(editor);
  ME_SendSelChange(editor);
}

Referenced by handle_wm_char().

◆ table_insert_cell()

ME_Paragraph * table_insert_cell	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor
	)

Definition at line 112 of file table.c.

{
    WCHAR tab = '\t';
 
    return table_insert_end_para( editor, editor->pCursors, &tab, 1, MEPF_CELL );
}

Referenced by ME_RTFSpecialCharHook(), and table_append_row().

◆ table_insert_row_end()

ME_Paragraph * table_insert_row_end	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor
	)

Definition at line 119 of file table.c.

{
    ME_Paragraph *para;
 
    para = table_insert_end_para( editor, cursor, L"\r\n", 2, MEPF_ROWEND );
    return para_prev( para );
}

Referenced by ME_RTFSpecialCharHook(), and table_append_row().

◆ table_insert_row_start()

ME_Paragraph * table_insert_row_start	(	ME_TextEditor *	editor,
		ME_Cursor *	cursor
	)

Definition at line 72 of file table.c.

{
    ME_Paragraph *para;
 
    para = table_insert_end_para( editor, cursor, L"\r\n", 2, MEPF_ROWSTART );
    return para_prev( para );
}

Referenced by ME_RTFParAttrHook(), table_append_row(), and table_insert_row_start_at_para().

◆ table_insert_row_start_at_para()

ME_Paragraph * table_insert_row_start_at_para	(	ME_TextEditor *	editor,
		ME_Paragraph *	para
	)

Definition at line 80 of file table.c.

{
    ME_Paragraph *prev_para, *end_para, *start_row;
    ME_Cursor cursor;
 
    cursor.para = para;
    cursor.run = para_first_run( para );
    cursor.nOffset = 0;
 
    start_row = table_insert_row_start( editor, &cursor );
 
    end_para = para_next( editor->pCursors[0].para );
    prev_para = para_next( start_row );
    para = para_next( prev_para );
 
    while (para != end_para)
    {
        para->cell = para_cell( prev_para );
        para->nFlags |= MEPF_CELL;
        para->nFlags &= ~(MEPF_ROWSTART | MEPF_ROWEND);
        para->fmt.dwMask |= PFM_TABLE | PFM_TABLEROWDELIMITER;
        para->fmt.wEffects |= PFE_TABLE;
        para->fmt.wEffects &= ~PFE_TABLEROWDELIMITER;
        prev_para = para;
        para = para_next( para );
    }
    return start_row;
}

Referenced by ME_RTFParAttrHook(), and ME_RTFSpecialCharHook().

◆ table_move_from_row_start()

void table_move_from_row_start ( ME_TextEditor * editor )

Definition at line 531 of file table.c.

{
  ME_Paragraph *para = editor->pCursors[0].para;
 
  if (para == editor->pCursors[1].para && para->nFlags & MEPF_ROWSTART)
  {
    /* The cursors should not be at the hidden start row paragraph without
     * a selection, so the cursor is moved into the first cell. */
    para = para_next( para );
    editor->pCursors[0].para = para;
    editor->pCursors[0].run = para_first_run( para );
    editor->pCursors[0].nOffset = 0;
    editor->pCursors[1] = editor->pCursors[0];
  }
}

Referenced by ME_KeyDown(), ME_Redo(), and ME_Undo().

◆ table_outer_para()

ME_Paragraph * table_outer_para ( ME_Paragraph * para )

Definition at line 158 of file table.c.

{
  if (para->nFlags & MEPF_ROWEND) para = para_prev( para );
  while (para_cell( para ))
  {
    para = table_row_start( para );
    if (!para_cell( para )) break;
    para = &ME_FindItemBack( cell_get_di( para_cell( para ) ), diParagraph )->member.para;
  }
  return para;
}

Referenced by para_range_invalidate(), and wrap_marked_paras_dc().

◆ table_protect_partial_deletion()

void table_protect_partial_deletion	(	ME_TextEditor *	editor,
		ME_Cursor *	c,
		int *	num_chars
	)

Definition at line 217 of file table.c.

{
  int start_ofs = ME_GetCursorOfs( c );
  ME_Cursor c2 = *c;
  ME_Paragraph *this_para = c->para, *end_para;
 
  ME_MoveCursorChars( editor, &c2, *num_chars, FALSE );
  end_para = c2.para;
  if (c2.run->nFlags & MERF_ENDPARA)
  {
    /* End offset might be in the middle of the end paragraph run.
     * If this is the case, then we need to use the next paragraph as the last
     * paragraphs.
     */
    int remaining = start_ofs + *num_chars - c2.run->nCharOfs - end_para->nCharOfs;
    if (remaining)
    {
      assert( remaining < c2.run->len );
      end_para = para_next( end_para );
    }
  }
  if (!editor->bEmulateVersion10) /* v4.1 */
  {
    if (para_cell( this_para ) != para_cell( end_para ) ||
        ((this_para->nFlags | end_para->nFlags) & (MEPF_ROWSTART | MEPF_ROWEND)))
    {
      while (this_para != end_para)
      {
        ME_Paragraph *next_para = para_next( this_para );
        BOOL truancate_del = FALSE;
        if (this_para->nFlags & MEPF_ROWSTART)
        {
          /* The following while loop assumes that next_para is MEPF_ROWSTART,
           * so moving back one paragraph lets it be processed as the start
           * of the row. */
          next_para = this_para;
          this_para = para_prev( this_para );
        }
        else if (para_cell( next_para) != para_cell( this_para ) || this_para->nFlags & MEPF_ROWEND)
        {
          /* Start of the deletion from after the start of the table row. */
          truancate_del = TRUE;
        }
        while (!truancate_del && next_para->nFlags & MEPF_ROWSTART)
        {
          next_para = para_next( table_row_end( next_para ) );
          if (next_para->nCharOfs > start_ofs + *num_chars)
          {
            /* End of deletion is not past the end of the table row. */
            next_para = para_next( this_para );
            /* Delete the end paragraph preceding the table row if the
             * preceding table row will be empty. */
            if (this_para->nCharOfs >= start_ofs) next_para = para_next( next_para );
            truancate_del = TRUE;
          }
          else this_para = para_prev( next_para );
        }
        if (truancate_del)
        {
          ME_Run *end_run = para_end_run( para_prev( next_para ) );
          int new_chars = next_para->nCharOfs - start_ofs - end_run->len;
          new_chars = max( new_chars, 0 );
          assert( new_chars <= *num_chars);
          *num_chars = new_chars;
          break;
        }
        this_para = next_para;
      }
    }
  }
  else /* v1.0 - 3.0 */
  {
    ME_Run *run;
    int chars_to_boundary;
 
    if ((this_para->nCharOfs != start_ofs || this_para == end_para) && para_in_table( this_para ))
    {
      run = c->run;
      /* Find the next tab or end paragraph to use as a delete boundary */
      while (!(run->nFlags & (MERF_TAB | MERF_ENDPARA)))
        run = run_next( run );
      chars_to_boundary = run->nCharOfs - c->run->nCharOfs - c->nOffset;
      *num_chars = min( *num_chars, chars_to_boundary );
    }
    else if (para_in_table( end_para ))
    {
      /* The deletion starts from before the row, so don't join it with
       * previous non-empty paragraphs. */
      ME_Paragraph *cur_para;
      run = NULL;
      if (start_ofs > this_para->nCharOfs)
      {
          cur_para = para_prev( end_para );
          run = para_end_run( cur_para );
      }
      if (!run)
      {
        cur_para = end_para;
        run = para_first_run( end_para );
      }
      if (run)
      {
        chars_to_boundary = cur_para->nCharOfs + run->nCharOfs - start_ofs;
        if (chars_to_boundary >= 0) *num_chars = min( *num_chars, chars_to_boundary );
      }
    }
    if (*num_chars < 0) *num_chars = 0;
  }
}

Referenced by ME_InternalDeleteText().

◆ table_row_end()

ME_Paragraph * table_row_end ( ME_Paragraph * para )

Definition at line 127 of file table.c.

{
  ME_Cell *cell;
 
  if (para->nFlags & MEPF_ROWEND) return para;
  if (para->nFlags & MEPF_ROWSTART) para = para_next( para );
  cell = para_cell( para );
  while (cell_next( cell ))
    cell = cell_next( cell );
 
  para = &ME_FindItemFwd( cell_get_di( cell ), diParagraph )->member.para;
  assert( para && para->nFlags & MEPF_ROWEND );
  return para;
}

Referenced by adjust_para_y(), cursor_from_virtual_coords(), cursor_move_line(), draw_table_borders(), ME_BeginRow(), ME_WrapTextParagraph(), pixel_pos_in_table_row(), stream_out_table_props(), table_append_row(), table_protect_partial_deletion(), table_row_end_cell(), and table_select_next_cell_or_append().

◆ table_row_end_cell()

ME_Cell * table_row_end_cell ( ME_Paragraph * para )

Definition at line 178 of file table.c.

{
    if (!para_in_table( para )) return NULL;
 
    para = para_prev( table_row_end( para ));
    return cell_next( para_cell( para ) );
}

Referenced by adjust_para_y(), cursor_move_line(), draw_paragraph(), draw_table_borders(), and ME_BeginRow().

◆ table_row_first_cell()

ME_Cell * table_row_first_cell ( ME_Paragraph * para )

Definition at line 170 of file table.c.

{
    if (!para_in_table( para )) return NULL;
 
    para = para_next( table_row_start( para ) );
    return para_cell( para );
}

Referenced by adjust_para_y(), cursor_move_line(), draw_paragraph(), ME_RTFSpecialCharHook(), pixel_pos_in_table_row(), stream_out_table_props(), and table_append_row().

◆ table_row_start()

ME_Paragraph * table_row_start ( ME_Paragraph * para )

Definition at line 142 of file table.c.

{
  ME_Cell *cell;
 
  if (para->nFlags & MEPF_ROWSTART) return para;
  if (para->nFlags & MEPF_ROWEND) para = para_prev( para );
  cell = para_cell( para );
 
  while (cell_prev( cell ))
    cell = cell_prev( cell );
 
  para = &ME_FindItemBack( cell_get_di( cell ), diParagraph )->member.para;
  assert( para && para->nFlags & MEPF_ROWSTART );
  return para;
}

Referenced by adjust_para_y(), cursor_move_line(), table_outer_para(), table_row_first_cell(), and table_select_next_cell_or_append().

◆ update_caret()

void update_caret ( ME_TextEditor * ed )

Definition at line 277 of file caret.c.

{
  int x, y, height;
 
  if (!editor->bHaveFocus) return;
  if (!ME_IsSelection(editor))
  {
    cursor_coords( editor, &editor->pCursors[0], &x, &y, &height );
    if (height != editor->caret_height) create_caret(editor);
    x = min(x, editor->rcFormat.right-1);
    ITextHost_TxSetCaretPos(editor->texthost, x, y);
    show_caret(editor);
  }
  else
    hide_caret(editor);
#ifdef __REACTOS__
  if (ImmIsIME(GetKeyboardLayout(0)))
  {
    HIMC hIMC = ImmGetContext(editor->hWnd);
    if (hIMC)
    {
      CHARFORMAT2W fmt;
      LOGFONTW lf;
      COMPOSITIONFORM CompForm;
      POINT pt = { x, y };
 
      CompForm.ptCurrentPos = pt;
      if (editor->styleFlags & ES_MULTILINE)
      {
        CompForm.dwStyle = CFS_RECT;
        CompForm.rcArea = editor->rcFormat;
      }
      else
      {
        CompForm.dwStyle = CFS_POINT;
        SetRectEmpty(&CompForm.rcArea);
      }
      ImmSetCompositionWindow(hIMC, &CompForm);
 
      fmt.cbSize = sizeof(fmt);
      ME_GetSelectionCharFormat(editor, &fmt);
 
      ZeroMemory(&lf, sizeof(lf));
      lf.lfCharSet = DEFAULT_CHARSET;
      if (fmt.dwMask & CFM_SIZE)
      {
        HDC hdc = CreateCompatibleDC(NULL);
        lf.lfHeight = -MulDiv(fmt.yHeight, GetDeviceCaps(hdc, LOGPIXELSY), 1440);
        DeleteDC(hdc);
      }
      if (fmt.dwMask & CFM_CHARSET)
        lf.lfCharSet = fmt.bCharSet;
      if (fmt.dwMask & CFM_FACE)
        lstrcpynW(lf.lfFaceName, fmt.szFaceName, ARRAY_SIZE(lf.lfFaceName));
      ImmSetCompositionFontW(hIMC, &lf);
 
      ImmReleaseContext(editor->hWnd, hIMC);
    }
  }
#endif
}

Referenced by editor_handle_message(), ME_ArrowKey(), ME_LButtonDown(), ME_MouseMove(), ME_UpdateRepaint(), set_selection(), and table_handle_tab().

◆ wrap_marked_paras_dc()

BOOL wrap_marked_paras_dc	(	ME_TextEditor *	editor,
		HDC	hdc,
		BOOL	invalidate
	)

Definition at line 1023 of file wrap.c.

{
  ME_Paragraph *para, *next;
  struct wine_rb_entry *entry, *next_entry = NULL;
  ME_Context c;
  int totalWidth = editor->nTotalWidth, prev_width;
  struct repaint_range repaint = { NULL, NULL };
 
  if (!editor->marked_paras.root) return FALSE;
 
  ME_InitContext( &c, editor, hdc );
 
  entry = wine_rb_head( editor->marked_paras.root );
  while (entry)
  {
    para = WINE_RB_ENTRY_VALUE( entry, ME_Paragraph, marked_entry );
 
    /* If the first entry lies inside a table, go back to the start
       of the table to ensure cell heights are kept in sync. */
    if (!next_entry && para_in_table( para ) && para != table_outer_para( para ))
    {
        para = table_outer_para( para );
        next_entry = entry;
    }
    else
        next_entry = wine_rb_next( entry );
 
    c.pt = para->pt;
    prev_width = para->nWidth;
    ME_WrapTextParagraph( editor, &c, para );
    if (prev_width == totalWidth && para->nWidth < totalWidth)
      totalWidth = get_total_width(editor);
    else
      totalWidth = max(totalWidth, para->nWidth);
 
    update_repaint( para, &repaint );
    adjust_para_y( para, &c, &repaint );
 
    if (para_next( para ))
    {
      if (c.pt.x != para_next( para )->pt.x || c.pt.y != para_next( para )->pt.y ||
          para_in_table( para ))
      {
        next = para;
        while (para_next( next ) && &next->marked_entry != next_entry &&
               next != &editor->pBuffer->pLast->member.para)
        {
          update_repaint( para_next( next ), &repaint );
          para_next( next )->pt = c.pt;
          adjust_para_y( para_next( next ), &c, &repaint );
          next = para_next( next );
        }
      }
    }
    entry = next_entry;
  }
  wine_rb_clear( &editor->marked_paras, NULL, NULL );
 
  editor->sizeWindow.cx = c.rcView.right-c.rcView.left;
  editor->sizeWindow.cy = c.rcView.bottom-c.rcView.top;
 
  editor->nTotalLength = editor->pBuffer->pLast->member.para.pt.y;
  editor->nTotalWidth = totalWidth;
 
  ME_DestroyContext(&c);
 
  if (invalidate && (repaint.start || editor->nTotalLength < editor->nLastTotalLength))
    para_range_invalidate( editor, repaint.start, repaint.end);
  return !!repaint.start;
}

Referenced by fnTextSrv_TxDraw(), fnTextSrv_TxGetNaturalSize(), and ME_WrapMarkedParagraphs().

Variable Documentation

◆ DECLSPEC_HIDDEN

BOOL me_debug DECLSPEC_HIDDEN

extern

Definition at line 28 of file editor.h.

Macros

Functions

Variables

Macro Definition Documentation

◆ CP_UNICODE

◆ InitFormatEtc

◆ ITextHost2_TxDestroyCaret

◆ ITextHost2_TxFreeTextServicesNotification

◆ ITextHost2_TxGetEastAsianFlags

◆ ITextHost2_TxGetEditStyle

◆ ITextHost2_TxGetHorzExtent

◆ ITextHost2_TxGetPalette

◆ ITextHost2_TxGetWindow

◆ ITextHost2_TxGetWindowStyles

◆ ITextHost2_TxIsDoubleClickPending

◆ ITextHost2_TxSetCursor2

◆ ITextHost2_TxSetForegroundWindow

◆ ITextHost2_TxShowDropCaret

◆ ITextHost_OnTxCharFormatChange

◆ ITextHost_OnTxParaFormatChange

◆ ITextHost_TxActivate

◆ ITextHost_TxClientToScreen

◆ ITextHost_TxCreateCaret

◆ ITextHost_TxDeactivate

◆ ITextHost_TxEnableScrollBar

◆ ITextHost_TxGetAcceleratorPos

◆ ITextHost_TxGetBackStyle

◆ ITextHost_TxGetCharFormat

◆ ITextHost_TxGetClientRect

◆ ITextHost_TxGetDC

◆ ITextHost_TxGetExtent

◆ ITextHost_TxGetMaxLength

◆ ITextHost_TxGetParaFormat

◆ ITextHost_TxGetPasswordChar

◆ ITextHost_TxGetPropertyBits

◆ ITextHost_TxGetScrollBars

◆ ITextHost_TxGetSelectionBarWidth

◆ ITextHost_TxGetSysColor

◆ ITextHost_TxGetViewInset

◆ ITextHost_TxImmGetContext

◆ ITextHost_TxImmReleaseContext

◆ ITextHost_TxInvalidateRect

◆ ITextHost_TxKillTimer

◆ ITextHost_TxNotify

◆ ITextHost_TxReleaseDC

◆ ITextHost_TxScreenToClient

◆ ITextHost_TxScrollWindowEx

◆ ITextHost_TxSetCapture

◆ ITextHost_TxSetCaretPos

◆ ITextHost_TxSetCursor

◆ ITextHost_TxSetFocus

◆ ITextHost_TxSetScrollPos

◆ ITextHost_TxSetScrollRange

◆ ITextHost_TxSetTimer

◆ ITextHost_TxShowCaret

◆ ITextHost_TxShowScrollBar

◆ ITextHost_TxViewChange

◆ ITextServices_OnTxInPlaceActivate

◆ ITextServices_OnTxInPlaceDeactivate

◆ ITextServices_OnTxPropertyBitsChange

◆ ITextServices_OnTxSetCursor

◆ ITextServices_OnTxUIActivate

◆ ITextServices_OnTxUIDeactivate

◆ ITextServices_TxDraw

◆ ITextServices_TxGetBaseLinePos

◆ ITextServices_TxGetCachedSize

◆ ITextServices_TxGetCurTargetX

◆ ITextServices_TxGetDropTarget

◆ ITextServices_TxGetHScroll

◆ ITextServices_TxGetNaturalSize

◆ ITextServices_TxGetText

◆ ITextServices_TxGetVScroll

◆ ITextServices_TxQueryHitPoint

◆ ITextServices_TxSendMessage

◆ ITextServices_TxSetText

◆ RUN_IS_HIDDEN

◆ TXTHOST_VTABLE

◆ TXTSERV_VTABLE

Function Documentation

◆ add_undo_delete_run()