#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)

ME_Style *	ME_MakeStyle (CHARFORMAT2W *style)

void	ME_AddRefStyle (ME_Style *item)

void	ME_DestroyStyle (ME_Style *item)

void	ME_ReleaseStyle (ME_Style *item)

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

void	select_style (ME_Context c, ME_Style s)

void	ME_InitCharFormat2W (CHARFORMAT2W *pFmt)

void	ME_SaveTempStyle (ME_TextEditor editor, ME_Style style)

void	ME_ClearTempStyle (ME_TextEditor *editor)

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

void	ME_DumpStyle (ME_Style *s)

BOOL	cfany_to_cf2w (CHARFORMAT2W to, const CHARFORMAT2W from)

BOOL	cf2w_to_cfany (CHARFORMAT2W to, const CHARFORMAT2W from)

void	ME_CopyCharFormat (CHARFORMAT2W pDest, const CHARFORMAT2W pSrc)

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

void	ME_InsertBefore (ME_DisplayItem diWhere, ME_DisplayItem diWhat)

void	ME_Remove (ME_DisplayItem *diWhere)

ME_DisplayItem *	ME_FindItemBack (ME_DisplayItem *di, ME_DIType nTypeOrClass)

ME_DisplayItem *	ME_FindItemFwd (ME_DisplayItem *di, ME_DIType nTypeOrClass)

ME_DisplayItem *	ME_FindItemBackOrHere (ME_DisplayItem *di, ME_DIType nTypeOrClass)

ME_DisplayItem *	ME_MakeDI (ME_DIType type)

void	ME_DestroyDisplayItem (ME_DisplayItem *item)

void	ME_DumpDocument (ME_TextBuffer *buffer)

ME_String *	ME_MakeStringN (LPCWSTR szText, int nMaxChars)

ME_String *	ME_MakeStringR (WCHAR cRepeat, int nMaxChars)

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

ME_String *	ME_MakeStringEmpty (int len)

void	ME_DestroyString (ME_String *s)

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

ME_String *	ME_VSplitString (ME_String *orig, int nVPos)

int	ME_FindNonWhitespaceV (const ME_String *s, int nVChar)

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

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

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

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

void	ME_EndToUnicode (LONG codepage, LPVOID psz)

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)

int	ME_ReverseFindWhitespaceV (const ME_String *s, int nVChar)

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

void	row_first_cursor (ME_Row row, ME_Cursor cursor)

ME_Run *	row_first_run (ME_Row *row)

ME_Row *	row_from_cursor (ME_Cursor *cursor)

ME_Row *	row_from_row_number (ME_TextEditor *editor, int row_num)

ME_Row *	row_next (ME_Row *row)

ME_Row *	row_next_all_paras (ME_Row *row)

ME_Run *	row_next_run (ME_Row row, ME_Run run)

int	row_number_from_char_ofs (ME_TextEditor *editor, int ofs)

ME_Paragraph *	row_para (ME_Row *row)

ME_Row *	row_prev_all_paras (ME_Row *row)

static ME_DisplayItem *	row_get_di (ME_Row *row)

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

BOOL	cursor_next_run (ME_Cursor *cursor, BOOL all_para)

BOOL	cursor_prev_run (ME_Cursor *cursor, BOOL all_para)

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

int	run_char_ofs (ME_Run *run, int ofs)

ME_Run *	run_create (ME_Style *s, int nFlags)

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

void	ME_CheckCharOffsets (ME_TextEditor *editor)

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

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

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

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

BOOL	ME_CanJoinRuns (const ME_Run run1, const ME_Run run2)

void	run_join (ME_TextEditor editor, ME_Run run)

ME_Run *	run_next (ME_Run *run)

ME_Run *	run_next_all_paras (ME_Run *run)

ME_Run *	run_prev (ME_Run *run)

ME_Run *	run_prev_all_paras (ME_Run *run)

ME_Run *	run_split (ME_TextEditor editor, ME_Cursor cursor)

void	ME_UpdateRunFlags (ME_TextEditor editor, ME_Run run)

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

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

void	ME_SetSelectionCharFormat (ME_TextEditor editor, CHARFORMAT2W pFmt)

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

void	ME_GetSelectionCharFormat (ME_TextEditor editor, CHARFORMAT2W pFmt)

void	ME_GetDefaultCharFormat (ME_TextEditor editor, CHARFORMAT2W pFmt)

void	ME_SetDefaultCharFormat (ME_TextEditor editor, CHARFORMAT2W mod)

static ME_DisplayItem *	run_get_di (ME_Run *run)

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

BOOL	cursor_from_coords (ME_TextEditor editor, int x, int y, ME_Cursor cursor)

void	ME_SetCursorToStart (ME_TextEditor editor, ME_Cursor cursor)

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

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

void	hide_caret (ME_TextEditor *ed)

void	show_caret (ME_TextEditor *ed)

void	update_caret (ME_TextEditor *ed)

void	create_caret (ME_TextEditor *ed)

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

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

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

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

void	ME_InsertEndRowFromCursor (ME_TextEditor *editor, int nCursor)

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

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

int	ME_GetCursorOfs (const ME_Cursor *cursor)

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

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

BOOL	ME_IsSelection (ME_TextEditor *editor)

void	ME_DeleteSelection (ME_TextEditor *editor)

void	ME_SendSelChange (ME_TextEditor *editor)

HRESULT	editor_insert_oleobj (ME_TextEditor editor, const REOBJECT reo)

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

int	ME_GetTextLength (ME_TextEditor *editor)

int	ME_GetTextLengthEx (ME_TextEditor editor, const GETTEXTLENGTHEX how)

ME_Style *	ME_GetSelectionInsertStyle (ME_TextEditor *editor)

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

void	ME_DestroyContext (ME_Context *c)

BOOL	ME_WrapMarkedParagraphs (ME_TextEditor *editor)

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

void	ME_SendRequestResize (ME_TextEditor *editor, BOOL force)

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

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

void	editor_get_selection_para_fmt (ME_TextEditor editor, PARAFORMAT2 fmt)

void	editor_mark_rewrap_all (ME_TextEditor *editor)

void	editor_set_default_para_fmt (ME_TextEditor editor, PARAFORMAT2 pFmt)

BOOL	editor_set_selection_para_fmt (ME_TextEditor editor, const PARAFORMAT2 fmt)

void	ME_MakeFirstParagraph (ME_TextEditor *editor, HDC hdc)

void	ME_DumpParaStyle (ME_Paragraph *s)

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

int	get_total_width (ME_TextEditor *editor)

ME_Cell *	para_cell (ME_Paragraph *para)

void	para_destroy (ME_TextEditor editor, ME_Paragraph item)

ME_Row *	para_end_row (ME_Paragraph *para)

ME_Run *	para_end_run (ME_Paragraph *para)

ME_Row *	para_first_row (ME_Paragraph *para)

ME_Run *	para_first_run (ME_Paragraph *para)

BOOL	para_in_table (ME_Paragraph *para)

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

void	para_mark_add (ME_TextEditor editor, ME_Paragraph para)

void	para_mark_remove (ME_TextEditor editor, ME_Paragraph para)

void	para_mark_rewrap (ME_TextEditor editor, ME_Paragraph para)

ME_Paragraph *	para_next (ME_Paragraph *para)

void	para_num_clear (struct para_num *pn)

void	para_num_init (ME_Context c, ME_Paragraph para)

ME_Paragraph *	para_prev (ME_Paragraph *para)

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

static ME_DisplayItem *	para_get_di (ME_Paragraph *para)

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

void	ME_Repaint (ME_TextEditor *editor)

void	ME_RewrapRepaint (ME_TextEditor *editor)

void	ME_UpdateRepaint (ME_TextEditor *editor, BOOL update_now)

void	editor_ensure_visible (ME_TextEditor editor, ME_Cursor cursor)

void	ME_InvalidateSelection (ME_TextEditor *editor)

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

int	ME_twips2pointsX (const ME_Context *c, int x)

int	ME_twips2pointsY (const ME_Context *c, int y)

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

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

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

void	ME_ScrollUp (ME_TextEditor *editor, int cy)

void	ME_ScrollDown (ME_TextEditor *editor, int cy)

void	ME_ScrollLeft (ME_TextEditor *editor, int cx)

void	ME_ScrollRight (ME_TextEditor *editor, int cx)

void	ME_UpdateScrollBar (ME_TextEditor *editor)

int	ME_GetParaBorderWidth (const ME_Context *c, int flags)

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

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

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

void	ME_DeleteReObject (struct re_object *re_object)

void	richole_release_children (struct text_services *services)

ME_TextEditor *	ME_MakeEditor (ITextHost *texthost, BOOL bEmulateVersion10)

void	ME_DestroyEditor (ME_TextEditor *editor)

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

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

void	ME_RTFCharAttrHook (struct _RTF_Info *info)

void	ME_RTFParAttrHook (struct _RTF_Info *info)

void	ME_RTFTblAttrHook (struct _RTF_Info *info)

void	ME_RTFSpecialCharHook (struct _RTF_Info *info)

void	ME_StreamInFill (ME_InStream *stream)

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

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

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

ME_Paragraph *	editor_end_para (ME_TextEditor *editor)

ME_Paragraph *	editor_first_para (ME_TextEditor *editor)

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

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

ME_Cell *	cell_create (void)

ME_Paragraph *	cell_end_para (ME_Cell *cell)

ME_Paragraph *	cell_first_para (ME_Cell *cell)

ME_Cell *	cell_next (ME_Cell *cell)

ME_Cell *	cell_prev (ME_Cell *cell)

ME_Paragraph *	table_append_row (ME_TextEditor editor, ME_Paragraph table_row)

void	table_handle_tab (ME_TextEditor *editor, BOOL selected_row)

ME_Paragraph *	table_insert_cell (ME_TextEditor editor, ME_Cursor cursor)

ME_Paragraph *	table_insert_row_end (ME_TextEditor editor, ME_Cursor cursor)

ME_Paragraph *	table_insert_row_start (ME_TextEditor editor, ME_Cursor cursor)

ME_Paragraph *	table_insert_row_start_at_para (ME_TextEditor editor, ME_Paragraph para)

void	table_move_from_row_start (ME_TextEditor *editor)

ME_Paragraph *	table_outer_para (ME_Paragraph *para)

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

ME_Paragraph *	table_row_end (ME_Paragraph *para)

ME_Cell *	table_row_end_cell (ME_Paragraph *para)

ME_Cell *	table_row_first_cell (ME_Paragraph *para)

ME_Paragraph *	table_row_start (ME_Paragraph *para)

struct RTFTable *	ME_MakeTableDef (ME_TextEditor *editor)

void	ME_InitTableDef (ME_TextEditor editor, struct RTFTable tableDef)

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)

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

BOOL	add_undo_set_para_fmt (ME_TextEditor , const ME_Paragraph para)

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

BOOL	add_undo_join_paras (ME_TextEditor *, int pos)

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

void	ME_CommitUndo (ME_TextEditor *editor)

void	ME_ContinueCoalescingTransaction (ME_TextEditor *editor)

void	ME_CommitCoalescingUndo (ME_TextEditor *editor)

BOOL	ME_Undo (ME_TextEditor *editor)

BOOL	ME_Redo (ME_TextEditor *editor)

void	ME_EmptyUndoStack (ME_TextEditor *editor)

void	editor_disable_undo (ME_TextEditor *editor)

void	editor_enable_undo (ME_TextEditor *editor)

static BOOL	editor_undo_ignored (ME_TextEditor *editor)

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

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

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

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

void	release_typelib (void)

Variables
HINSTANCE	dll_instance

const IRichEditOleVtbl	re_ole_vtbl

const ITextDocument2OldVtbl	text_doc2old_vtbl

BOOL	me_debug

Macro Definition Documentation

◆ CP_UNICODE

#define CP_UNICODE 1200

Definition at line 92 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 32 of file editor.h.

◆ ITextHost2_TxDestroyCaret

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

Definition at line 382 of file editor.h.

◆ ITextHost2_TxFreeTextServicesNotification

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

Definition at line 378 of file editor.h.

◆ ITextHost2_TxGetEastAsianFlags

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

Definition at line 376 of file editor.h.

◆ ITextHost2_TxGetEditStyle

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

Definition at line 379 of file editor.h.

◆ ITextHost2_TxGetHorzExtent

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

Definition at line 383 of file editor.h.

◆ ITextHost2_TxGetPalette

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

Definition at line 375 of file editor.h.

◆ ITextHost2_TxGetWindow

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

Definition at line 373 of file editor.h.

◆ ITextHost2_TxGetWindowStyles

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

Definition at line 380 of file editor.h.

◆ ITextHost2_TxIsDoubleClickPending

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

Definition at line 372 of file editor.h.

◆ ITextHost2_TxSetCursor2

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

Definition at line 377 of file editor.h.

◆ ITextHost2_TxSetForegroundWindow

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

Definition at line 374 of file editor.h.

◆ ITextHost2_TxShowDropCaret

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

Definition at line 381 of file editor.h.

◆ ITextHost_OnTxCharFormatChange

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

Definition at line 364 of file editor.h.

◆ ITextHost_OnTxParaFormatChange

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

Definition at line 365 of file editor.h.

◆ ITextHost_TxActivate

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

Definition at line 351 of file editor.h.

◆ ITextHost_TxClientToScreen

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

Definition at line 350 of file editor.h.

◆ ITextHost_TxCreateCaret

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

Definition at line 340 of file editor.h.

◆ ITextHost_TxDeactivate

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

Definition at line 352 of file editor.h.

◆ ITextHost_TxEnableScrollBar

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

Definition at line 335 of file editor.h.

◆ ITextHost_TxGetAcceleratorPos

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

Definition at line 362 of file editor.h.

◆ ITextHost_TxGetBackStyle

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

Definition at line 358 of file editor.h.

◆ ITextHost_TxGetCharFormat

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

Definition at line 355 of file editor.h.

◆ ITextHost_TxGetClientRect

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

Definition at line 353 of file editor.h.

◆ ITextHost_TxGetDC

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

Definition at line 332 of file editor.h.

◆ ITextHost_TxGetExtent

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

Definition at line 363 of file editor.h.

◆ ITextHost_TxGetMaxLength

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

Definition at line 359 of file editor.h.

◆ ITextHost_TxGetParaFormat

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

Definition at line 356 of file editor.h.

◆ ITextHost_TxGetPasswordChar

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

Definition at line 361 of file editor.h.

◆ ITextHost_TxGetPropertyBits

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

Definition at line 366 of file editor.h.

◆ ITextHost_TxGetScrollBars

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

Definition at line 360 of file editor.h.

◆ ITextHost_TxGetSelectionBarWidth

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

Definition at line 370 of file editor.h.

◆ ITextHost_TxGetSysColor

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

Definition at line 357 of file editor.h.

◆ ITextHost_TxGetViewInset

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

Definition at line 354 of file editor.h.

◆ ITextHost_TxImmGetContext

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

Definition at line 368 of file editor.h.

◆ ITextHost_TxImmReleaseContext

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

Definition at line 369 of file editor.h.

◆ ITextHost_TxInvalidateRect

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

Definition at line 338 of file editor.h.

◆ ITextHost_TxKillTimer

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

Definition at line 344 of file editor.h.

◆ ITextHost_TxNotify

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

Definition at line 367 of file editor.h.

◆ ITextHost_TxReleaseDC

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

Definition at line 333 of file editor.h.

◆ ITextHost_TxScreenToClient

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

Definition at line 349 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 345 of file editor.h.

◆ ITextHost_TxSetCapture

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

Definition at line 346 of file editor.h.

◆ ITextHost_TxSetCaretPos

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

Definition at line 342 of file editor.h.

◆ ITextHost_TxSetCursor

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

Definition at line 348 of file editor.h.

◆ ITextHost_TxSetFocus

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

Definition at line 347 of file editor.h.

◆ ITextHost_TxSetScrollPos

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

Definition at line 337 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 336 of file editor.h.

◆ ITextHost_TxSetTimer

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

Definition at line 343 of file editor.h.

◆ ITextHost_TxShowCaret

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

Definition at line 341 of file editor.h.

◆ ITextHost_TxShowScrollBar

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

Definition at line 334 of file editor.h.

◆ ITextHost_TxViewChange

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

Definition at line 339 of file editor.h.

◆ ITextServices_OnTxInPlaceActivate

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

Definition at line 420 of file editor.h.

◆ ITextServices_OnTxInPlaceDeactivate

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

Definition at line 421 of file editor.h.

◆ ITextServices_OnTxPropertyBitsChange

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

Definition at line 430 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 418 of file editor.h.

◆ ITextServices_OnTxUIActivate

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

Definition at line 422 of file editor.h.

◆ ITextServices_OnTxUIDeactivate

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

Definition at line 423 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 415 of file editor.h.

◆ ITextServices_TxGetBaseLinePos

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

Definition at line 427 of file editor.h.

◆ ITextServices_TxGetCachedSize

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

Definition at line 431 of file editor.h.

◆ ITextServices_TxGetCurTargetX

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

Definition at line 426 of file editor.h.

◆ ITextServices_TxGetDropTarget

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

Definition at line 429 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 416 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 428 of file editor.h.

◆ ITextServices_TxGetText

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

Definition at line 424 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 417 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 419 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 414 of file editor.h.

◆ ITextServices_TxSetText

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

Definition at line 425 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 29 of file editor.h.

◆ TXTHOST_VTABLE

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

Definition at line 329 of file editor.h.

◆ TXTSERV_VTABLE

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

Definition at line 412 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 = malloc( (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 318 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 579 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 = malloc( 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 245 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(), editor_insert_oleobj(), 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_from_coords()

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

Definition at line 1070 of file caret.c.

{
    x += editor->horz_si.nPos;
    y += editor->vert_si.nPos;
    return cursor_from_virtual_coords( editor, x, y, cursor, FALSE );
}

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

◆ 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 46 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 5785 of file richole.c.

{
  IDataObject*  ido;
  IViewObject*  ivo;
  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 (!run->reobj->obj.poleobj) return;
 
  if (SUCCEEDED(IOleObject_QueryInterface(run->reobj->obj.poleobj, &IID_IViewObject, (void**)&ivo)))
  {
    HRESULT hr;
    RECTL bounds;
 
    convert_sizel(c, &run->reobj->obj.sizel, &sz);
    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);
    }
 
    bounds.left = x;
    bounds.top = y - sz.cy;
    bounds.right = x + sz.cx;
    bounds.bottom = y;
 
    hr = IViewObject_Draw(ivo, DVASPECT_CONTENT, -1, 0, 0, 0, c->hDC, &bounds, NULL, NULL, 0);
    if (FAILED(hr))
    {
      WARN("failed to draw object: %#08lx\n", hr);
    }
 
    IViewObject_Release(ivo);
    return;
  }
 
  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.hBitmap, sizeof(dibsect), &dibsect);
    hMemDC = CreateCompatibleDC(c->hDC);
    old_bm = SelectObject(hMemDC, stgm.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.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.hEnhMetaFile, &rc);
    break;
  default:
    FIXME("Unsupported tymed %ld\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 2362 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_disable_undo()

void editor_disable_undo ( ME_TextEditor * editor )

Definition at line 483 of file undo.c.

{
    ME_EmptyUndoStack(editor);
    editor->undo_ctl_state = undoDisabled;
}

Referenced by ITextDocument2Old_fnUndo().

◆ 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->in_place_active) {
    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_enable_undo()

void editor_enable_undo ( ME_TextEditor * editor )

Definition at line 489 of file undo.c.

{
    if (editor->undo_ctl_state == undoDisabled)
    {
        editor->undo_ctl_state = undoActive;
    }
}

Referenced by editor_handle_message(), and ITextDocument2Old_fnUndo().

◆ editor_end_para()

ME_Paragraph * editor_end_para ( ME_TextEditor * editor )

Definition at line 282 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 1210 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->in_place_active)
    return;
 
  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(), ME_UpdateRepaint(), and set_selection().

◆ editor_first_para()

ME_Paragraph * editor_first_para ( ME_TextEditor * editor )

Definition at line 276 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 903 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 848 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 3266 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 */
    LONG from, to;
    LONG *pfrom = wParam ? (LONG *)wParam : &from;
    LONG *pto = lParam ? (LONG *)lParam : &to;
    ME_GetSelectionOfs(editor, pfrom, 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 = (%ld,%ld)\n", pRange->cpMin, pRange->cpMax);
    return 0;
  }
  case EM_SETUNDOLIMIT:
  {
    editor_enable_undo(editor);
    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;
    LONG from, to;
    int 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 %ld, 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:
  {
    LONG 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==%Ix\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:
  {
    LONG nFrom, nTo;
    int 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 = %ld max = %ld 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(%Id)==%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;
    POINTL *pt = (POINTL *)lParam;
 
    cursor_from_coords(editor, pt->x, pt->y, &cursor);
    return ME_GetCursorOfs(&cursor);
  }
  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 = malloc(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
        free(lpCompStr);
 
#ifndef __REACTOS__
        if (dwIndex == GCS_COMPSTR)
          set_selection_cursors(editor,editor->imeStartIndex,
                          editor->imeStartIndex + dwBufLen/sizeof(WCHAR));
        else
          editor->imeStartIndex = ME_GetCursorOfs(&editor->pCursors[0]);
#endif
    }
    ITextHost_TxImmReleaseContext(editor->texthost, hIMC);
    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_insert_oleobj()

HRESULT editor_insert_oleobj	(	ME_TextEditor *	editor,
		const REOBJECT *	reo
	)

Definition at line 504 of file caret.c.

{
  ME_Run *run, *prev;
  const WCHAR space = ' ';
  struct re_object *reobj_prev = NULL;
  ME_Cursor *cursor, cursor_from_ofs;
  ME_Style *style;
  HRESULT hr;
  SIZEL extent;
 
  if (editor->lpOleCallback)
  {
    hr = IRichEditOleCallback_QueryInsertObject(editor->lpOleCallback, (LPCLSID)&reo->clsid, reo->pstg, REO_CP_SELECTION);
    if (hr != S_OK)
      return hr;
  }
 
  extent = reo->sizel;
  if (!extent.cx && !extent.cy && reo->poleobj)
  {
    hr = IOleObject_GetExtent( reo->poleobj, DVASPECT_CONTENT, &extent );
    if (FAILED(hr))
    {
      extent.cx = 0;
      extent.cy = 0;
    }
  }
 
  if (reo->cp == REO_CP_SELECTION)
    cursor = editor->pCursors;
  else
  {
    cursor_from_char_ofs( editor, reo->cp, &cursor_from_ofs );
    cursor = &cursor_from_ofs;
  }
  style = style_get_insert_style( editor, cursor );
 
  if (ME_IsSelection(editor))
    ME_DeleteSelection(editor);
 
  run = run_insert( editor, cursor, style, &space, 1, MERF_GRAPHICS );
 
  run->reobj = create_re_object( reo, run );
  run->reobj->obj.sizel = extent;
 
  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 );
  return S_OK;
}

Referenced by insert_static_object(), and IRichEditOle_fnInsertObject().

◆ editor_mark_rewrap_all()

void editor_mark_rewrap_all ( ME_TextEditor * editor )

Definition at line 235 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_TextEditor *	editor,
		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
    {
        /* update position in marked tree, if added */
        if (para->nFlags & MEPF_REWRAP)
            para_mark_remove( editor, para );
        para->nCharOfs += shift;
        if (para->nFlags & MEPF_REWRAP)
            para_mark_add( editor, para );
        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 2831 of file editor.c.

{
    ME_Cursor pos;
    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 if (cursor_from_coords( editor, x, y, &pos ))
    {
        ME_Run *run = pos.run;
 
        if (is_link( run )) cursor = cursor_hand;
 
        else if (ME_IsSelection( editor ))
        {
            LONG start, end;
            int 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 958 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 873 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().

◆ editor_undo_ignored()

static BOOL editor_undo_ignored ( ME_TextEditor * editor )

inlinestatic

Definition at line 401 of file editor.h.

{
    return editor->undo_ctl_state != undoActive || editor->nUndoMode == umIgnore;
}

Referenced by add_undo(), ME_CommitCoalescingUndo(), ME_CommitUndo(), ME_ContinueCoalescingTransaction(), ME_PlayUndoItem(), ME_Redo(), and ME_Undo().

◆ get_text()

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

inlinestatic

Definition at line 41 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 3133 of file editor.c.

{
  int x,y;
  ME_Cursor cursor; /* The start of the clicked text. */
  ME_Run *run;
  ENLINK info;
 
  x = (short)LOWORD(lParam);
  y = (short)HIWORD(lParam);
  if (!cursor_from_coords( editor, x, y, &cursor )) 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 1471 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 = malloc(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);
    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 103 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 575 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 516 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_CheckCharOffsets()

void ME_CheckCharOffsets ( ME_TextEditor * editor )

Definition at line 178 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 = %08lx\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_undo_ignored(editor))
    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_undo_ignored(editor))
    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(), paste_emf(), set_textfont_prop(), and textrange_set_font().

◆ 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_undo_ignored(editor))
    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 5919 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 5911 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);
    free(reobj);
}

Referenced by ME_DestroyDisplayItem().

◆ ME_DeleteSelection()

void ME_DeleteSelection ( ME_TextEditor * editor )

Definition at line 1425 of file caret.c.

{
  LONG 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(), editor_insert_oleobj(), ME_InsertEndRowFromCursor(), 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);
    }
    free(item->member.run.glyphs);
    free(item->member.run.clusters);
    ME_ReleaseStyle(item->member.run.style);
  }
  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 3077 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();
 
  free(editor->pBuffer);
  free(editor->pCursors);
  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 );
  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 );
  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 785 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:",     "%ld", dxStartIndent);
  DUMP(PFM_STARTINDENT,    "Start indent:",      "%ld", dxStartIndent);
  DUMP(PFM_RIGHTINDENT,    "Right indent:",      "%ld", dxRightIndent);
  DUMP(PFM_OFFSET,         "Offset:",            "%ld", 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, "%lx ", pFmt->rgxTabs[i]);
    p += sprintf(p, "\n");
  }
  DUMP(PFM_SPACEBEFORE,    "Space Before:",      "%ld", dySpaceBefore);
  DUMP(PFM_SPACEAFTER,     "Space After:",       "%ld", dySpaceAfter);
  DUMP(PFM_LINESPACING,    "Line spacing:",      "%ld", 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:            %ld\n", pFmt->yHeight);
  else
    p += sprintf(p, "\nFont size:            N/A\n");
 
  if (pFmt->dwMask & CFM_OFFSET)
    p += sprintf(p, "Char offset:          %ld\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)  /* NOTE don't use editor_undo_ignored() here! */
    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_disable_undo(), 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)
    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 876 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->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 923 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 847 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 5708 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.hBitmap, sizeof(dibsect), &dibsect);
    pSize->cx = dibsect.dsBm.bmWidth;
    pSize->cy = dibsect.dsBm.bmHeight;
    break;
  case TYMED_ENHMF:
    GetEnhMetaFileHeader(stgm.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 %ld\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 541 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 674 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 858 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 1434 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,
		LONG *	from,
		LONG *	to
	)

Definition at line 42 of file caret.c.

{
  *from = ME_GetCursorOfs(&editor->pCursors[0]);
  *to =   ME_GetCursorOfs(&editor->pCursors[1]);
 
  if (*from > *to)
  {
    LONG 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 4325 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. */
  if (run == para_end_run( para_prev( editor_end_para( editor ) ) ) && bEOP && buflen)
  {
    *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 568 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_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 = 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 584 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( editor, 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 1253 of file paint.c.

{
  ME_Paragraph *sel_start, *sel_end;
  ME_Paragraph *repaint_start = NULL, *repaint_end = NULL;
  LONG 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 1419 of file caret.c.

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

Referenced by editor_insert_oleobj(), editor_set_cursor(), handle_EM_SETCHARFORMAT(), handle_wm_char(), ME_GetSelectionCharFormat(), ME_InsertEndRowFromCursor(), 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 98 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 1156 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 = calloc(1, 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 2936 of file editor.c.

{
  ME_TextEditor *ed = malloc( sizeof(*ed) );
  int i;
  LONG selbarwidth;
  HRESULT hr;
  HDC hdc;
 
  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 );
 
  hdc = ITextHost_TxGetDC( ed->texthost );
  ME_MakeFirstParagraph( ed, hdc );
  /* 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 = malloc( 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->undo_ctl_state = undoActive;
  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->freeze_count = 0;
  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);
 
  wrap_marked_paras_dc( ed, hdc, FALSE );
  ITextHost_TxReleaseDC( ed->texthost, hdc );
 
  return ed;
}

Referenced by create_text_services().

◆ ME_MakeFirstParagraph()

void ME_MakeFirstParagraph	(	ME_TextEditor *	editor,
		HDC	hdc
	)

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;
 
  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);
}

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( string_free );
 
  if (!s) return NULL;
  s->nLen = nMaxChars;
  s->nBuffer = ME_GetOptimalBuffer(s->nLen + 1);
  s->szData = malloc( s->nBuffer * sizeof(WCHAR) );
  if (!s->szData)
  {
    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 = malloc(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 = calloc(1, 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 1218 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 709 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 789 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
      {
        ME_Paragraph *other_para = para_next( para );
        if (!para_next( other_para ))
        {
          if (cursor->run == run) return FALSE;
          nOffset = 0;
          break;
        }
        if (other_para->nFlags & MEPF_ROWSTART) other_para = para_next( other_para );
        if (cursor->run == run) {
          para = other_para;
          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 654 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 613 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_undo_ignored(editor)) 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(), ITextDocument2Old_fnRedo(), 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(), editor_insert_oleobj(), handle_enter(), handle_wm_char(), ITextRange_fnSetText(), ME_ClearTempStyle(), ME_DestroyDisplayItem(), ME_DestroyEditor(), ME_InsertEndRowFromCursor(), 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 121 of file paint.c.

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

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

◆ ME_ReplaceSel()

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

Definition at line 3170 of file editor.c.

{
  LONG from, to;
  int 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 160 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(), ITextDocument2Old_fnUnfreeze(), and ME_SetZoom().

◆ ME_RTFCharAttrHook()

void ME_RTFCharAttrHook ( struct _RTF_Info * info )

Definition at line 425 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 556 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 = calloc(1, 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 = calloc(1, 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 943 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;
              free(tableDef);
            }
          }
        }
        else
        {
          info->tableDef = tableDef->parent;
          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 869 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 1136 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 1141 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 1146 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 1131 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 1137 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 1439 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=%ld cpMax=%ld 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 782 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 753 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 1310 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 1562 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 1193 of file writer.c.

{
  ME_Cursor start;
  int nChars;
 
  if (dwFormat & SFF_SELECTION) {
    LONG 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 1177 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 = malloc(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 171 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 179 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_undo_ignored(editor)) 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(), ITextDocument2Old_fnUndo(), and ME_KeyDown().

◆ ME_UpdateRepaint()

void ME_UpdateRepaint	(	ME_TextEditor *	editor,
		BOOL	update_now
	)

Definition at line 132 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 );
 
  if (!editor->freeze_count)
    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 467 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 1151 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(), scroll_abs(), set_textfont_prop(), and textrange_set_font().

◆ 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 1103 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(), set_textfont_prop(), table_select_next_cell_or_append(), and textrange_set_font().

◆ 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 236 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 681 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( editor, 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 editor_propagate_char_ofs(), 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 editor_propagate_char_ofs(), and 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 434 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 390 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 1111 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 538 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( editor, 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 5943 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 125 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 233 of file run.c.

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

Referenced by draw_run(), and IRichEditOle_fnGetObject().

◆ run_create()

ME_Run * run_create	(	ME_Style *	s,
		int	nFlags
	)

Definition at line 348 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 162 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 380 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( editor, 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 editor_insert_oleobj(), ME_InsertEndRowFromCursor(), ME_InsertTextFromCursor(), and ME_PlayUndoItem().

◆ run_join()

void run_join	(	ME_TextEditor *	editor,
		ME_Run *	run
	)

Definition at line 278 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(), editor_insert_oleobj(), ME_FindText(), ME_GetCharFormat(), ME_InternalDeleteText(), and run_insert().

◆ run_split()

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

Definition at line 310 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 1091 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 1121 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 1126 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 && c->current_style->font_cache)
    {
        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 2151 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 );
    editor_ensure_visible( editor, &editor->pCursors[0] );
    if (!editor->bHideSelection) ME_InvalidateSelection( editor );
    update_caret( editor );
    ME_Repaint( 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)
    {
      LONG 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(), editor_insert_oleobj(), handle_enter(), handle_wm_char(), ITextRange_fnSetText(), ME_GetSelectionInsertStyle(), ME_InsertEndRowFromCursor(), 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 1032 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 = 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 = 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_destroy( &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(), ME_MakeEditor(), and ME_WrapMarkedParagraphs().

Variable Documentation

◆ dll_instance

HINSTANCE dll_instance

extern

Definition at line 253 of file editor.c.

Referenced by DllMain(), and editor_set_cursor().

◆ me_debug

BOOL me_debug

extern

Definition at line 254 of file editor.c.

Referenced by draw_paragraph().

◆ re_ole_vtbl

const IRichEditOleVtbl re_ole_vtbl

extern

Definition at line 1419 of file richole.c.

Referenced by create_text_services().

◆ text_doc2old_vtbl

const ITextDocument2OldVtbl text_doc2old_vtbl

extern

Definition at line 4527 of file richole.c.

Referenced by create_text_services().

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()