ReactOS 0.4.16-dev-1105-gafe29ee
run.c File Reference
#include "editor.h"
Include dependency graph for run.c:

Go to the source code of this file.

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (richedit)
 
 WINE_DECLARE_DEBUG_CHANNEL (richedit_check)
 
 WINE_DECLARE_DEBUG_CHANNEL (richedit_lists)
 
BOOL cursor_next_run (ME_Cursor *cursor, BOOL all_para)
 
BOOL cursor_prev_run (ME_Cursor *cursor, BOOL all_para)
 
ME_Runrun_next (ME_Run *run)
 
ME_Runrun_prev (ME_Run *run)
 
ME_Runrun_next_all_paras (ME_Run *run)
 
ME_Runrun_prev_all_paras (ME_Run *run)
 
BOOL ME_CanJoinRuns (const ME_Run *run1, const ME_Run *run2)
 
void editor_propagate_char_ofs (ME_Paragraph *para, ME_Run *run, int shift)
 
void ME_CheckCharOffsets (ME_TextEditor *editor)
 
int run_char_ofs (ME_Run *run, int ofs)
 
void cursor_from_char_ofs (ME_TextEditor *editor, int char_ofs, ME_Cursor *cursor)
 
void run_join (ME_TextEditor *editor, ME_Run *run)
 
ME_Runrun_split (ME_TextEditor *editor, ME_Cursor *cursor)
 
ME_Runrun_create (ME_Style *s, int flags)
 
ME_Runrun_insert (ME_TextEditor *editor, ME_Cursor *cursor, ME_Style *style, const WCHAR *str, int len, int flags)
 
static BOOL run_is_splittable (const ME_Run *run)
 
static BOOL run_is_entirely_ws (const ME_Run *run)
 
void ME_UpdateRunFlags (ME_TextEditor *editor, ME_Run *run)
 
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)
 
static void ME_GetTextExtent (ME_Context *c, LPCWSTR szText, int nChars, ME_Style *s, SIZE *size)
 
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)
 
SIZE ME_GetRunSizeCommon (ME_Context *c, const ME_Paragraph *para, ME_Run *run, int nLen, int startx, int *pAscent, int *pDescent)
 
void ME_SetSelectionCharFormat (ME_TextEditor *editor, CHARFORMAT2W *pFmt)
 
void ME_SetCharFormat (ME_TextEditor *editor, ME_Cursor *start, ME_Cursor *end, CHARFORMAT2W *fmt)
 
static void run_copy_char_fmt (ME_Run *run, CHARFORMAT2W *fmt)
 
void ME_GetDefaultCharFormat (ME_TextEditor *editor, CHARFORMAT2W *pFmt)
 
void ME_GetSelectionCharFormat (ME_TextEditor *editor, CHARFORMAT2W *pFmt)
 
void ME_GetCharFormat (ME_TextEditor *editor, const ME_Cursor *from, const ME_Cursor *to, CHARFORMAT2W *fmt)
 

Function Documentation

◆ cursor_from_char_ofs()

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

Definition at line 240 of file run.c.

241{
242 ME_Paragraph *para;
243 ME_Run *run;
244
245 char_ofs = min( max( char_ofs, 0 ), ME_GetTextLength( editor ) );
246
247 /* Find the paragraph at the offset. */
248 for (para = editor_first_para( editor );
249 para_next( para )->nCharOfs <= char_ofs;
250 para = para_next( para ))
251 ;
252
253 char_ofs -= para->nCharOfs;
254
255 /* Find the run at the offset. */
256 for (run = para_first_run( para );
257 run_next( run ) && run_next( run )->nCharOfs <= char_ofs;
258 run = run_next( run ))
259 ;
260
261 char_ofs -= run->nCharOfs;
262
263 cursor->para = para;
264 cursor->run = run;
265 cursor->nOffset = char_ofs;
266}
int ME_GetTextLength(ME_TextEditor *editor)
Definition: caret.c:83
ME_Paragraph * editor_first_para(ME_TextEditor *editor)
Definition: editor.c:279
ME_Run * run_next(ME_Run *run)
Definition: run.c:68
ME_Run * para_first_run(ME_Paragraph *para) DECLSPEC_HIDDEN
Definition: para.c:104
ME_Paragraph * para_next(ME_Paragraph *para) DECLSPEC_HIDDEN
Definition: para.c:57
const char cursor[]
Definition: icontest.c:13
#define min(a, b)
Definition: monoChain.cc:55
int nCharOfs
Definition: editstr.h:161
#define max(a, b)
Definition: svc.c:63

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

◆ cursor_next_run()

BOOL cursor_next_run ( ME_Cursor cursor,
BOOL  all_para 
)

Definition at line 30 of file run.c.

31{
33
34 while (p->type != diTextEnd)
35 {
36 if (p->type == diParagraph && !all_para) return FALSE;
37 else if (p->type == diRun)
38 {
39 cursor->run = &p->member.run;
40 cursor->para = cursor->run->para;
41 cursor->nOffset = 0;
42 return TRUE;
43 }
44 p = p->next;
45 }
46 return FALSE;
47}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
static ME_DisplayItem * run_get_di(ME_Run *run)
Definition: editor.h:163
@ diTextEnd
Definition: editstr.h:88
@ diRun
Definition: editstr.h:86
@ diParagraph
Definition: editstr.h:84
GLfloat GLfloat p
Definition: glext.h:8902
struct define * next
Definition: compiler.c:65
struct tagME_DisplayItem * next
Definition: editstr.h:256

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.

50{
52
53 while (p->type != diTextStart)
54 {
55 if (p->type == diParagraph && !all_para) return FALSE;
56 else if (p->type == diRun)
57 {
58 cursor->run = &p->member.run;
59 cursor->para = cursor->run->para;
60 cursor->nOffset = 0;
61 return TRUE;
62 }
63 p = p->prev;
64 }
65 return FALSE;
66}
@ diTextStart
Definition: editstr.h:83
struct tagME_DisplayItem * prev
Definition: editstr.h:256

Referenced by run_prev(), and run_prev_all_paras().

◆ editor_propagate_char_ofs()

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

Definition at line 147 of file run.c.

148{
149 assert( !para ^ !run );
150
151 if (run)
152 {
153 para = para_next( run->para );
154 do
155 {
156 run->nCharOfs += shift;
157 run = run_next( run );
158 } while (run);
159 }
160
161 do
162 {
163 para->nCharOfs += shift;
164 para = para_next( para );
165 } while (para);
166}
#define assert(x)
Definition: debug.h:53
#define shift
Definition: input.c:1755
struct tagME_Paragraph * para
Definition: editstr.h:160

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

◆ ME_CanJoinRuns()

BOOL ME_CanJoinRuns ( const ME_Run run1,
const ME_Run run2 
)

Definition at line 129 of file run.c.

130{
131 if ((run1->nFlags | run2->nFlags) & MERF_NOJOIN)
132 return FALSE;
133 if (run1->style != run2->style)
134 return FALSE;
135 if ((run1->nFlags & MERF_STYLEFLAGS) != (run2->nFlags & MERF_STYLEFLAGS))
136 return FALSE;
137 return TRUE;
138}
#define MERF_STYLEFLAGS
Definition: editstr.h:102
#define MERF_NOJOIN
Definition: editstr.h:130
ME_Style * style
Definition: editstr.h:159
int nFlags
Definition: editstr.h:164

Referenced by ME_PrepareParagraphForWrapping().

◆ ME_CharFromPoint()

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

Definition at line 570 of file run.c.

571{
573 int ret;
574 HDC hdc = ITextHost_TxGetDC( editor->texthost );
575
576 ME_InitContext( &c, editor, hdc );
577 ret = ME_CharFromPointContext( &c, cx, run, closest, visual_order );
580 return ret;
581}
void ME_DestroyContext(ME_Context *c)
Definition: context.c:44
void ME_InitContext(ME_Context *c, ME_TextEditor *editor, HDC hDC)
Definition: context.c:23
int ME_CharFromPointContext(ME_Context *c, int cx, ME_Run *run, BOOL closest, BOOL visual_order)
Definition: run.c:511
#define ITextHost_TxGetDC(This)
Definition: editor.h:333
#define ITextHost_TxReleaseDC(This, a)
Definition: editor.h:334
const GLubyte * c
Definition: glext.h:8905
#define c
Definition: ke_i.h:80
HDC hdc
Definition: main.c:9
static HDC
Definition: imagelist.c:88
_Out_opt_ int * cx
Definition: commctrl.h:585
ITextHost2 * texthost
Definition: editstr.h:384
int ret

Referenced by row_cursor().

◆ ME_CharFromPointContext()

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

Definition at line 511 of file run.c.

512{
513 ME_String *mask_text = NULL;
514 WCHAR *str;
515 int fit = 0;
516 SIZE sz, sz2, sz3;
517 if (!run->len || cx <= 0)
518 return 0;
519
520 if (run->nFlags & (MERF_TAB | MERF_ENDCELL))
521 {
522 if (!closest || cx < run->nWidth / 2) return 0;
523 return 1;
524 }
525
526 if (run->nFlags & MERF_GRAPHICS)
527 {
528 SIZE sz;
529 ME_GetOLEObjectSize(c, run, &sz);
530 if (!closest || cx < sz.cx / 2) return 0;
531 return 1;
532 }
533
534 if (run->para->nFlags & MEPF_COMPLEX)
535 {
536 int cp, trailing;
537 if (visual_order && run->script_analysis.fRTL) cx = run->nWidth - cx - 1;
538
539 ScriptXtoCP( cx, run->len, run->num_glyphs, run->clusters, run->vis_attrs, run->advances, &run->script_analysis,
540 &cp, &trailing );
541 TRACE("x %d cp %d trailing %d (run width %d) rtl %d log order %d\n", cx, cp, trailing, run->nWidth,
543 return closest ? cp + trailing : cp;
544 }
545
546 if (c->editor->password_char)
547 {
548 mask_text = ME_MakeStringR( c->editor->password_char, run->len );
549 str = mask_text->szData;
550 }
551 else
552 str = get_text( run, 0 );
553
554 select_style(c, run->style);
555 GetTextExtentExPointW(c->hDC, str, run->len,
556 cx, &fit, NULL, &sz);
557 if (closest && fit != run->len)
558 {
559 GetTextExtentPoint32W(c->hDC, str, fit, &sz2);
560 GetTextExtentPoint32W(c->hDC, str, fit + 1, &sz3);
561 if (cx >= (sz2.cx+sz3.cx)/2)
562 fit = fit + 1;
563 }
564
565 ME_DestroyString( mask_text );
566
567 return fit;
568}
#define NULL
Definition: types.h:112
HRESULT WINAPI ScriptXtoCP(int iX, int cChars, int cGlyphs, const WORD *pwLogClust, const SCRIPT_VISATTR *psva, const int *piAdvance, const SCRIPT_ANALYSIS *psa, int *piCP, int *piTrailing)
Definition: usp10.c:2854
void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize) DECLSPEC_HIDDEN
Definition: richole.c:5649
void select_style(ME_Context *c, ME_Style *s) DECLSPEC_HIDDEN
Definition: style.c:369
void ME_DestroyString(ME_String *s) DECLSPEC_HIDDEN
Definition: string.c:96
static WCHAR * get_text(const ME_Run *run, int offset)
Definition: editor.h:42
ME_String * ME_MakeStringR(WCHAR cRepeat, int nMaxChars) DECLSPEC_HIDDEN
Definition: string.c:85
#define MERF_TAB
Definition: editstr.h:106
#define MERF_ENDCELL
Definition: editstr.h:108
#define MERF_GRAPHICS
Definition: editstr.h:104
#define MEPF_COMPLEX
Definition: editstr.h:145
POINT cp
Definition: magnifier.c:59
const WCHAR * str
#define TRACE(s)
Definition: solgame.cpp:4
LONG cx
Definition: kdterminal.h:27
int num_glyphs
Definition: editstr.h:170
SCRIPT_VISATTR * vis_attrs
Definition: editstr.h:172
int * advances
Definition: editstr.h:173
SCRIPT_ANALYSIS script_analysis
Definition: editstr.h:169
int nWidth
Definition: editstr.h:163
int len
Definition: editstr.h:162
WORD * clusters
Definition: editstr.h:176
WCHAR * szData
Definition: editstr.h:55
WORD fLogicalOrder
Definition: usp10.h:144
BOOL WINAPI GetTextExtentExPointW(_In_ HDC hdc, _In_reads_(cchString) LPCWSTR lpszString, _In_ int cchString, _In_ int nMaxExtent, _Out_opt_ LPINT lpnFit, _Out_writes_to_opt_(cchString, *lpnFit) LPINT lpnDx, _Out_ LPSIZE lpSize)
BOOL WINAPI GetTextExtentPoint32W(_In_ HDC hdc, _In_reads_(c) LPCWSTR lpString, _In_ int c, _Out_ LPSIZE psizl)
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by find_split_point(), and ME_CharFromPoint().

◆ ME_CheckCharOffsets()

void ME_CheckCharOffsets ( ME_TextEditor editor)

Definition at line 173 of file run.c.

174{
175 ME_DisplayItem *p = editor->pBuffer->pFirst;
176 int ofs = 0, ofsp = 0;
177
178 if (!TRACE_ON(richedit_check))
179 return;
180
181 TRACE_(richedit_check)("Checking begin\n");
182 if(TRACE_ON(richedit_lists))
183 {
184 TRACE_(richedit_lists)("---\n");
185 ME_DumpDocument(editor->pBuffer);
186 }
187 do {
189 switch(p->type) {
190 case diTextEnd:
191 TRACE_(richedit_check)("tend, real ofsp = %d, counted = %d\n", p->member.para.nCharOfs, ofsp+ofs);
192 assert(ofsp+ofs == p->member.para.nCharOfs);
193 TRACE_(richedit_check)("Checking finished\n");
194 return;
195 case diParagraph:
196 TRACE_(richedit_check)("para, real ofsp = %d, counted = %d\n", p->member.para.nCharOfs, ofsp+ofs);
197 assert(ofsp+ofs == p->member.para.nCharOfs);
198 ofsp = p->member.para.nCharOfs;
199 ofs = 0;
200 break;
201 case diRun:
202 TRACE_(richedit_check)("run, real ofs = %d (+ofsp = %d), counted = %d, len = %d, txt = %s, flags=%08x, fx&mask = %08x\n",
203 p->member.run.nCharOfs, p->member.run.nCharOfs+ofsp, ofsp+ofs,
204 p->member.run.len, debugstr_run( &p->member.run ),
205 p->member.run.nFlags,
206 p->member.run.style->fmt.dwMask & p->member.run.style->fmt.dwEffects);
207 assert(ofs == p->member.run.nCharOfs);
208 assert(p->member.run.len);
209 ofs += p->member.run.len;
210 break;
211 case diCell:
212 TRACE_(richedit_check)("cell\n");
213 break;
214 default:
215 assert(0);
216 }
217 } while(1);
218 TRACE_(richedit_check)("Checking finished\n");
219}
#define TRACE_(x)
Definition: compat.h:76
#define TRACE_ON(x)
Definition: compat.h:75
void ME_DumpDocument(ME_TextBuffer *buffer) DECLSPEC_HIDDEN
Definition: list.c:142
ME_DisplayItem * ME_FindItemFwd(ME_DisplayItem *di, ME_DIType nTypeOrClass) DECLSPEC_HIDDEN
Definition: list.c:89
static const char * debugstr_run(const ME_Run *run)
Definition: editor.h:47
@ diRunOrParagraphOrEnd
Definition: editstr.h:96
@ diCell
Definition: editstr.h:85
ME_DisplayItem * pFirst
Definition: editstr.h:267
ME_TextBuffer * pBuffer
Definition: editstr.h:388

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

◆ ME_GetCharFormat()

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

Definition at line 871 of file run.c.

873{
874 ME_Run *run, *run_end, *prev_run;
875 CHARFORMAT2W tmp;
876
877 run = from->run;
878 /* special case - if selection is empty, take previous char's formatting */
879 if (from->run == to->run && from->nOffset == to->nOffset)
880 {
881 if (!from->nOffset && (prev_run = run_prev( run ))) run = prev_run;
882 run_copy_char_fmt( run, fmt );
883 return;
884 }
885
886 run_end = to->run;
887 if (!to->nOffset) run_end = run_prev_all_paras( run_end );
888
889 run_copy_char_fmt( run, fmt );
890
891 if (run == run_end) return;
892
893 do {
894 /* FIXME add more style feature comparisons */
897
898 run = run_next_all_paras( run );
899
900 memset( &tmp, 0, sizeof(tmp) );
901 tmp.cbSize = sizeof(tmp);
902 run_copy_char_fmt( run, &tmp );
903
904 assert((tmp.dwMask & dwAttribs) == dwAttribs);
905 /* reset flags that differ */
906
907 if (fmt->yHeight != tmp.yHeight) fmt->dwMask &= ~CFM_SIZE;
908 if (fmt->dwMask & CFM_FACE)
909 {
910 if (!(tmp.dwMask & CFM_FACE))
911 fmt->dwMask &= ~CFM_FACE;
912 else if (wcscmp( fmt->szFaceName, tmp.szFaceName ) ||
913 fmt->bPitchAndFamily != tmp.bPitchAndFamily)
914 fmt->dwMask &= ~CFM_FACE;
915 }
916 if (fmt->yHeight != tmp.yHeight) fmt->dwMask &= ~CFM_SIZE;
917 if (fmt->bUnderlineType != tmp.bUnderlineType) fmt->dwMask &= ~CFM_UNDERLINETYPE;
918 if (fmt->dwMask & CFM_COLOR)
919 {
920 if (!((fmt->dwEffects&CFE_AUTOCOLOR) & (tmp.dwEffects&CFE_AUTOCOLOR)))
921 {
922 if (fmt->crTextColor != tmp.crTextColor)
923 fmt->dwMask &= ~CFM_COLOR;
924 }
925 }
926
927 fmt->dwMask &= ~((fmt->dwEffects ^ tmp.dwEffects) & dwEffects);
928 fmt->dwEffects = tmp.dwEffects;
929
930 } while(run != run_end);
931}
ME_Run * run_prev(ME_Run *run)
Definition: run.c:82
static void run_copy_char_fmt(ME_Run *run, CHARFORMAT2W *fmt)
Definition: run.c:831
ME_Run * run_prev_all_paras(ME_Run *run)
Definition: run.c:110
ME_Run * run_next_all_paras(ME_Run *run)
Definition: run.c:96
unsigned long DWORD
Definition: ntddk_ex.h:95
#define CFM_PROTECTED
Definition: richedit.h:336
#define CFM_STRIKEOUT
Definition: richedit.h:335
#define CFE_AUTOCOLOR
Definition: richedit.h:414
#define CFM_ITALIC
Definition: richedit.h:333
#define CFM_LINK
Definition: richedit.h:337
#define CFM_SIZE
Definition: richedit.h:362
#define CFM_BOLD
Definition: richedit.h:332
#define CFM_UNDERLINETYPE
Definition: richedit.h:355
#define CFM_FACE
Definition: richedit.h:360
#define CFM_UNDERLINE
Definition: richedit.h:334
#define CFM_COLOR
Definition: richedit.h:361
#define CFM_SUPERSCRIPT
Definition: richedit.h:349
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
#define memset(x, y, z)
Definition: compat.h:39
CardRegion * from
Definition: spigame.cpp:19
DWORD dwMask
Definition: richedit.h:306
WCHAR szFaceName[LF_FACESIZE]
Definition: richedit.h:313
DWORD dwEffects
Definition: richedit.h:307
BYTE bUnderlineType
Definition: richedit.h:321
LONG yHeight
Definition: richedit.h:308
COLORREF crTextColor
Definition: richedit.h:310
BYTE bPitchAndFamily
Definition: richedit.h:312
Definition: dsound.c:943
int nOffset
Definition: editstr.h:276
ME_Run * run
Definition: editstr.h:275

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

◆ ME_GetDefaultCharFormat()

void ME_GetDefaultCharFormat ( ME_TextEditor editor,
CHARFORMAT2W pFmt 
)

Definition at line 842 of file run.c.

843{
844 ME_CopyCharFormat(pFmt, &editor->pBuffer->pDefaultStyle->fmt);
845}
void ME_CopyCharFormat(CHARFORMAT2W *pDest, const CHARFORMAT2W *pSrc) DECLSPEC_HIDDEN
Definition: style.c:230
CHARFORMAT2W fmt
Definition: editstr.h:72
ME_Style * pDefaultStyle
Definition: editstr.h:269

Referenced by editor_handle_message().

◆ ME_GetRunSizeCommon()

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

Definition at line 669 of file run.c.

671{
672 SIZE size;
673
674 nLen = min( nLen, run->len );
675
676 if (run->nFlags & MERF_ENDPARA)
677 {
678 nLen = min( nLen, 1 );
679 ME_GetTextExtent( c, L" ", nLen, run->style, &size );
680 }
681 else if (para->nFlags & MEPF_COMPLEX)
682 {
683 size.cx = run->nWidth;
684 }
685 else if (c->editor->password_char)
686 {
687 ME_String *szMasked = ME_MakeStringR( c->editor->password_char, nLen );
688 ME_GetTextExtent(c, szMasked->szData, nLen,run->style, &size);
689 ME_DestroyString(szMasked);
690 }
691 else
692 {
693 ME_GetTextExtent(c, get_text( run, 0 ), nLen, run->style, &size);
694 }
695 *pAscent = run->style->tm.tmAscent;
696 *pDescent = run->style->tm.tmDescent;
697 size.cy = *pAscent + *pDescent;
698
699 if (run->nFlags & MERF_TAB)
700 {
701 int pos = 0, i = 0, ppos, shift = 0;
702 const PARAFORMAT2 *pFmt = &para->fmt;
703
704 if (c->editor->bEmulateVersion10 && /* v1.0 - 3.0 */
705 pFmt->dwMask & PFM_TABLE && pFmt->wEffects & PFE_TABLE)
706 /* The horizontal gap shifts the tab positions to leave the gap. */
707 shift = pFmt->dxOffset * 2;
708 do {
709 if (i < pFmt->cTabCount)
710 {
711 /* Only one side of the horizontal gap is needed at the end of
712 * the table row. */
713 if (i == pFmt->cTabCount -1)
714 shift = shift >> 1;
715 pos = shift + (pFmt->rgxTabs[i]&0x00FFFFFF);
716 i++;
717 }
718 else
719 {
721 }
722 ppos = ME_twips2pointsX(c, pos);
723 if (ppos > startx + run->pt.x) {
724 size.cx = ppos - startx - run->pt.x;
725 break;
726 }
727 } while(1);
728 size.cy = *pAscent + *pDescent;
729 return size;
730 }
731 if (run->nFlags & MERF_GRAPHICS)
732 {
733 ME_GetOLEObjectSize(c, run, &size);
734 if (size.cy > *pAscent)
735 *pAscent = size.cy;
736 /* descent is unchanged */
737 return size;
738 }
739 return size;
740}
static void ME_GetTextExtent(ME_Context *c, LPCWSTR szText, int nChars, ME_Style *s, SIZE *size)
Definition: run.c:588
int ME_twips2pointsX(const ME_Context *c, int x) DECLSPEC_HIDDEN
Definition: paint.c:167
#define MERF_ENDPARA
Definition: editstr.h:121
GLsizeiptr size
Definition: glext.h:5919
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define L(x)
Definition: ntvdm.h:50
#define PFM_TABLE
Definition: richedit.h:870
#define lDefaultTab
Definition: richedit.h:215
#define PFE_TABLE
Definition: richedit.h:944
DWORD dwMask
Definition: richedit.h:667
LONG dxOffset
Definition: richedit.h:672
LONG rgxTabs[MAX_TAB_STOPS]
Definition: richedit.h:675
SHORT cTabCount
Definition: richedit.h:674
WORD wEffects
Definition: richedit.h:669
PARAFORMAT2 fmt
Definition: editstr.h:203
POINT pt
Definition: editstr.h:166
TEXTMETRICW tm
Definition: editstr.h:75
long x
Definition: polytest.cpp:48
LONG tmAscent
Definition: wingdi.h:2384
LONG tmDescent
Definition: wingdi.h:2385

Referenced by calc_run_extent().

◆ ME_GetSelectionCharFormat()

void ME_GetSelectionCharFormat ( ME_TextEditor editor,
CHARFORMAT2W pFmt 
)

Definition at line 853 of file run.c.

854{
855 ME_Cursor *from, *to;
856 if (!ME_IsSelection(editor) && editor->pBuffer->pCharStyle)
857 {
858 ME_CopyCharFormat(pFmt, &editor->pBuffer->pCharStyle->fmt);
859 return;
860 }
861 ME_GetSelection(editor, &from, &to);
862 ME_GetCharFormat(editor, from, to, pFmt);
863}
BOOL ME_IsSelection(ME_TextEditor *editor)
Definition: caret.c:1400
int ME_GetSelection(ME_TextEditor *editor, ME_Cursor **from, ME_Cursor **to)
Definition: caret.c:57
void ME_GetCharFormat(ME_TextEditor *editor, const ME_Cursor *from, const ME_Cursor *to, CHARFORMAT2W *fmt)
Definition: run.c:871
ME_Style * pCharStyle
Definition: editstr.h:268

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

◆ ME_GetTextExtent()

static void ME_GetTextExtent ( ME_Context c,
LPCWSTR  szText,
int  nChars,
ME_Style s,
SIZE size 
)
static

Definition at line 588 of file run.c.

589{
590 if (c->hDC)
591 {
592 select_style( c, s );
593 GetTextExtentPoint32W( c->hDC, szText, nChars, size );
594 }
595 else
596 {
597 size->cx = 0;
598 size->cy = 0;
599 }
600}
GLdouble s
Definition: gl.h:2039

Referenced by ME_GetRunSizeCommon(), and ME_PointFromCharContext().

◆ ME_PointFromChar()

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

Definition at line 649 of file run.c.

650{
652 int ret;
653 HDC hdc = ITextHost_TxGetDC( editor->texthost );
654
655 ME_InitContext( &c, editor, hdc );
656 ret = ME_PointFromCharContext( &c, pRun, nOffset, visual_order );
659
660 return ret;
661}
int ME_PointFromCharContext(ME_Context *c, ME_Run *pRun, int nOffset, BOOL visual_order)
Definition: run.c:608

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

◆ ME_PointFromCharContext()

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

Definition at line 608 of file run.c.

609{
610 SIZE size;
611 ME_String *mask_text = NULL;
612 WCHAR *str;
613
614 if (pRun->nFlags & MERF_GRAPHICS)
615 {
616 if (nOffset)
617 ME_GetOLEObjectSize(c, pRun, &size);
618 return nOffset != 0;
619 } else if (pRun->nFlags & MERF_ENDPARA) {
620 nOffset = 0;
621 }
622
623 if (pRun->para->nFlags & MEPF_COMPLEX)
624 {
625 int x;
626 ScriptCPtoX( nOffset, FALSE, pRun->len, pRun->num_glyphs, pRun->clusters,
627 pRun->vis_attrs, pRun->advances, &pRun->script_analysis, &x );
628 if (visual_order && pRun->script_analysis.fRTL) x = pRun->nWidth - x - 1;
629 return x;
630 }
631 if (c->editor->password_char)
632 {
633 mask_text = ME_MakeStringR( c->editor->password_char, pRun->len );
634 str = mask_text->szData;
635 }
636 else
637 str = get_text( pRun, 0 );
638
639 ME_GetTextExtent(c, str, nOffset, pRun->style, &size);
640 ME_DestroyString( mask_text );
641 return size.cx;
642}
HRESULT WINAPI ScriptCPtoX(int iCP, BOOL fTrailing, int cChars, int cGlyphs, const WORD *pwLogClust, const SCRIPT_VISATTR *psva, const int *piAdvance, const SCRIPT_ANALYSIS *psa, int *piX)
Definition: usp10.c:2650
GLint GLint GLint GLint GLint x
Definition: gl.h:1548

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

◆ ME_SetCharFormat()

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

Definition at line 777 of file run.c.

778{
779 ME_Run *run, *start_run = start->run, *end_run = NULL;
780
781 if (end && start->run == end->run && start->nOffset == end->nOffset)
782 return;
783
784 if (start->nOffset == start->run->len)
785 start_run = run_next_all_paras( start->run );
786 else if (start->nOffset)
787 {
788 /* run_split() may or may not update the cursors, depending on whether they
789 * are selection cursors, but we need to make sure they are valid. */
790 int split_offset = start->nOffset;
791 ME_Run *split_run = run_split( editor, start );
792 start_run = start->run;
793 if (end && end->run == split_run)
794 {
795 end->run = start->run;
796 end->nOffset -= split_offset;
797 }
798 }
799
800 if (end)
801 {
802 if (end->nOffset == end->run->len)
803 end_run = run_next_all_paras( end->run );
804 else
805 {
806 if (end->nOffset) run_split( editor, end );
807 end_run = end->run;
808 }
809 }
810
811 for (run = start_run; run != end_run; run = run_next_all_paras( run ))
812 {
813 ME_Style *new_style = ME_ApplyStyle( editor, run->style, fmt );
814 ME_Paragraph *para = run->para;
815
816 add_undo_set_char_fmt( editor, para->nCharOfs + run->nCharOfs,
817 run->len, &run->style->fmt );
818 ME_ReleaseStyle( run->style );
819 run->style = new_style;
820
821 /* The para numbering style depends on the eop style */
822 if ((run->nFlags & MERF_ENDPARA) && para->para_num.style)
823 {
824 ME_ReleaseStyle(para->para_num.style);
825 para->para_num.style = NULL;
826 }
827 para_mark_rewrap( editor, para );
828 }
829}
ME_Run * run_split(ME_TextEditor *editor, ME_Cursor *cursor)
Definition: run.c:305
void ME_ReleaseStyle(ME_Style *item) DECLSPEC_HIDDEN
Definition: style.c:462
BOOL add_undo_set_char_fmt(ME_TextEditor *, int pos, int len, const CHARFORMAT2W *fmt) DECLSPEC_HIDDEN
Definition: undo.c:164
ME_Style * ME_ApplyStyle(ME_TextEditor *ed, ME_Style *sSrc, CHARFORMAT2W *style) DECLSPEC_HIDDEN
Definition: style.c:156
void para_mark_rewrap(ME_TextEditor *editor, ME_Paragraph *para) DECLSPEC_HIDDEN
Definition: para.c:26
GLuint start
Definition: gl.h:1545
GLuint GLuint end
Definition: gl.h:1545
struct para_num para_num
Definition: editstr.h:214

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

◆ ME_SetSelectionCharFormat()

void ME_SetSelectionCharFormat ( ME_TextEditor editor,
CHARFORMAT2W pFmt 
)

Definition at line 748 of file run.c.

749{
750 if (!ME_IsSelection(editor))
751 {
752 ME_Style *s;
753 if (!editor->pBuffer->pCharStyle)
754 editor->pBuffer->pCharStyle = style_get_insert_style( editor, editor->pCursors );
755 s = ME_ApplyStyle(editor, editor->pBuffer->pCharStyle, pFmt);
757 editor->pBuffer->pCharStyle = s;
758 } else {
759 ME_Cursor *from, *to;
760 ME_GetSelection(editor, &from, &to);
761 ME_SetCharFormat(editor, from, to, pFmt);
762 }
763}
void ME_SetCharFormat(ME_TextEditor *editor, ME_Cursor *start, ME_Cursor *end, CHARFORMAT2W *fmt)
Definition: run.c:777
ME_Style * style_get_insert_style(ME_TextEditor *editor, ME_Cursor *cursor) DECLSPEC_HIDDEN
Definition: style.c:476
ME_Cursor * pCursors
Definition: editstr.h:389

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

◆ ME_UpdateRunFlags()

void ME_UpdateRunFlags ( ME_TextEditor editor,
ME_Run run 
)

Definition at line 462 of file run.c.

463{
464 assert(run->nCharOfs >= 0);
465
466 if (RUN_IS_HIDDEN(run) || run->nFlags & MERF_TABLESTART)
467 run->nFlags |= MERF_HIDDEN;
468 else
469 run->nFlags &= ~MERF_HIDDEN;
470
471 if (run_is_splittable( run ))
472 run->nFlags |= MERF_SPLITTABLE;
473 else
474 run->nFlags &= ~MERF_SPLITTABLE;
475
476 if (!(run->nFlags & MERF_NOTEXT))
477 {
478 if (run_is_entirely_ws( run ))
480 else
481 {
482 run->nFlags &= ~MERF_WHITESPACE;
483
484 if (ME_IsWSpace( *get_text( run, 0 ) ))
485 run->nFlags |= MERF_STARTWHITE;
486 else
487 run->nFlags &= ~MERF_STARTWHITE;
488
489 if (ME_IsWSpace( *get_text( run, run->len - 1 ) ))
490 run->nFlags |= MERF_ENDWHITE;
491 else
492 run->nFlags &= ~MERF_ENDWHITE;
493 }
494 }
495 else
497}
static BOOL run_is_splittable(const ME_Run *run)
Definition: run.c:426
static BOOL run_is_entirely_ws(const ME_Run *run)
Definition: run.c:444
static int ME_IsWSpace(WCHAR ch)
Definition: editor.h:99
#define RUN_IS_HIDDEN(run)
Definition: editor.h:30
#define MERF_STARTWHITE
Definition: editstr.h:115
#define MERF_NOTEXT
Definition: editstr.h:132
#define MERF_ENDWHITE
Definition: editstr.h:117
#define MERF_HIDDEN
Definition: editstr.h:125
#define MERF_SPLITTABLE
Definition: editstr.h:113
#define MERF_TABLESTART
Definition: editstr.h:127
#define MERF_WHITESPACE
Definition: editstr.h:119

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

◆ run_char_ofs()

int run_char_ofs ( ME_Run run,
int  ofs 
)

Definition at line 228 of file run.c.

229{
230 return run->para->nCharOfs + run->nCharOfs + ofs;
231}

Referenced by draw_run().

◆ run_copy_char_fmt()

static void run_copy_char_fmt ( ME_Run run,
CHARFORMAT2W fmt 
)
static

Definition at line 831 of file run.c.

832{
833 ME_CopyCharFormat( fmt, &run->style->fmt );
834}

Referenced by ME_GetCharFormat().

◆ run_create()

ME_Run * run_create ( ME_Style s,
int  flags 
)

Definition at line 343 of file run.c.

344{
346 ME_Run *run = &item->member.run;
347
348 if (!item) return NULL;
349
350 ME_AddRefStyle( s );
351 run->style = s;
352 run->reobj = NULL;
353 run->nFlags = flags;
354 run->nCharOfs = -1;
355 run->len = 0;
356 run->para = NULL;
357 run->num_glyphs = 0;
358 run->max_glyphs = 0;
359 run->glyphs = NULL;
360 run->vis_attrs = NULL;
361 run->advances = NULL;
362 run->offsets = NULL;
363 run->max_clusters = 0;
364 run->clusters = NULL;
365 return run;
366}
void ME_AddRefStyle(ME_Style *item) DECLSPEC_HIDDEN
Definition: style.c:454
ME_DisplayItem * ME_MakeDI(ME_DIType type) DECLSPEC_HIDDEN
Definition: list.c:133
GLbitfield flags
Definition: glext.h:7161
static ATOM item
Definition: dde.c:856
GOFFSET * offsets
Definition: editstr.h:174
int max_clusters
Definition: editstr.h:175
WORD * glyphs
Definition: editstr.h:171
struct re_object * reobj
Definition: editstr.h:167
int max_glyphs
Definition: editstr.h:170

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

◆ run_insert()

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

Definition at line 375 of file run.c.

377{
378 ME_Run *insert_before = cursor->run, *run, *prev;
379
380 if (cursor->nOffset)
381 {
382 if (cursor->nOffset == insert_before->len)
383 {
384 insert_before = run_next_all_paras( insert_before );
385 if (!insert_before) insert_before = cursor->run; /* Always insert before the final eop run */
386 }
387 else
388 {
389 run_split( editor, cursor );
390 insert_before = cursor->run;
391 }
392 }
393
394 add_undo_delete_run( editor, insert_before->para->nCharOfs + insert_before->nCharOfs, len );
395
396 run = run_create( style, flags );
397 run->nCharOfs = insert_before->nCharOfs;
398 run->len = len;
399 run->para = insert_before->para;
400 ME_InsertString( run->para->text, run->nCharOfs, str, len );
401 ME_InsertBefore( run_get_di( insert_before ), run_get_di( run ) );
402 TRACE("Shift length:%d\n", len);
403 editor_propagate_char_ofs( NULL, insert_before, len );
404 para_mark_rewrap( editor, insert_before->para );
405
406 /* Move any cursors that were at the end of the previous run to the end of the inserted run */
407 prev = run_prev_all_paras( run );
408 if (prev)
409 {
410 int i;
411
412 for (i = 0; i < editor->nCursors; i++)
413 {
414 if (editor->pCursors[i].run == prev &&
415 editor->pCursors[i].nOffset == prev->len)
416 {
417 editor->pCursors[i].run = run;
418 editor->pCursors[i].nOffset = len;
419 }
420 }
421 }
422
423 return run;
424}
Arabic default style
Definition: afstyles.h:94
ME_Run * run_create(ME_Style *s, int flags)
Definition: run.c:343
void editor_propagate_char_ofs(ME_Paragraph *para, ME_Run *run, int shift)
Definition: run.c:147
BOOL add_undo_delete_run(ME_TextEditor *, int pos, int len) DECLSPEC_HIDDEN
Definition: undo.c:204
void ME_InsertBefore(ME_DisplayItem *diWhere, ME_DisplayItem *diWhat) DECLSPEC_HIDDEN
Definition: list.c:26
BOOL ME_InsertString(ME_String *s, int ofs, const WCHAR *insert, int len) DECLSPEC_HIDDEN
Definition: string.c:103
GLenum GLsizei len
Definition: glext.h:6722

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

◆ run_is_entirely_ws()

static BOOL run_is_entirely_ws ( const ME_Run run)
static

Definition at line 444 of file run.c.

445{
446 WCHAR *str = get_text( run, 0 ), *p;
447 int i;
448
449 for (i = 0, p = str; i < run->len; i++, p++)
450 if (!ME_IsWSpace( *p )) return FALSE;
451
452 return TRUE;
453}

Referenced by ME_UpdateRunFlags().

◆ run_is_splittable()

static BOOL run_is_splittable ( const ME_Run run)
static

Definition at line 426 of file run.c.

427{
428 WCHAR *str = get_text( run, 0 ), *p;
429 int i;
430 BOOL found_ink = FALSE;
431
432 for (i = 0, p = str; i < run->len; i++, p++)
433 {
434 if (ME_IsWSpace( *p ))
435 {
436 if (found_ink) return TRUE;
437 }
438 else
439 found_ink = TRUE;
440 }
441 return FALSE;
442}
unsigned int BOOL
Definition: ntddk_ex.h:94

Referenced by ME_UpdateRunFlags().

◆ run_join()

void run_join ( ME_TextEditor editor,
ME_Run run 
)

Definition at line 273 of file run.c.

274{
275 ME_Run *next = run_next( run );
276 int i;
277
278 assert( run );
279 assert( run->nCharOfs != -1 );
280 para_mark_rewrap( editor, run->para );
281
282 /* Update all cursors so that they don't contain the soon deleted run */
283 for (i = 0; i < editor->nCursors; i++)
284 {
285 if (editor->pCursors[i].run == next)
286 {
287 editor->pCursors[i].run = run;
288 editor->pCursors[i].nOffset += run->len;
289 }
290 }
291
292 run->len += next->len;
295 ME_UpdateRunFlags( editor, run );
296 ME_CheckCharOffsets( editor );
297}
void ME_UpdateRunFlags(ME_TextEditor *editor, ME_Run *run)
Definition: run.c:462
void ME_CheckCharOffsets(ME_TextEditor *editor)
Definition: run.c:173
void ME_DestroyDisplayItem(ME_DisplayItem *item) DECLSPEC_HIDDEN
Definition: list.c:115
void ME_Remove(ME_DisplayItem *diWhere) DECLSPEC_HIDDEN
Definition: list.c:35
static unsigned __int64 next
Definition: rand_nt.c:6

Referenced by ME_PrepareParagraphForWrapping().

◆ run_next()

◆ run_next_all_paras()

ME_Run * run_next_all_paras ( ME_Run run)

Definition at line 96 of file run.c.

97{
99
100 cursor.run = run;
101 cursor.para = run->para;
102 cursor.nOffset = 0;
103
104 if (cursor_next_run( &cursor, TRUE ))
105 return cursor.run;
106
107 return NULL;
108}

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.

83{
85
86 cursor.run = run;
87 cursor.para = run->para;
88 cursor.nOffset = 0;
89
91 return cursor.run;
92
93 return NULL;
94}
BOOL cursor_prev_run(ME_Cursor *cursor, BOOL all_para)
Definition: run.c:49

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.

111{
113
114 cursor.run = run;
115 cursor.para = run->para;
116 cursor.nOffset = 0;
117
118 if (cursor_prev_run( &cursor, TRUE ))
119 return cursor.run;
120
121 return NULL;
122}

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

◆ run_split()

ME_Run * run_split ( ME_TextEditor editor,
ME_Cursor cursor 
)

Definition at line 305 of file run.c.

306{
307 ME_Run *run = cursor->run, *new_run;
308 int i;
309 int nOffset = cursor->nOffset;
310
311 assert( !(run->nFlags & MERF_NONTEXT) );
312
313 new_run = run_create( run->style, run->nFlags & MERF_SPLITMASK );
314 new_run->nCharOfs = run->nCharOfs + nOffset;
315 new_run->len = run->len - nOffset;
316 new_run->para = run->para;
317 run->len = nOffset;
318 cursor->run = new_run;
319 cursor->nOffset = 0;
320
321 ME_InsertBefore( run_get_di( run )->next, run_get_di( new_run ) );
322
323 ME_UpdateRunFlags( editor, run );
324 ME_UpdateRunFlags( editor, new_run );
325 for (i = 0; i < editor->nCursors; i++)
326 {
327 if (editor->pCursors[i].run == run &&
328 editor->pCursors[i].nOffset >= nOffset)
329 {
330 editor->pCursors[i].run = new_run;
331 editor->pCursors[i].nOffset -= nOffset;
332 }
333 }
334 para_mark_rewrap( editor, run->para );
335 return run;
336}
#define MERF_NONTEXT
Definition: editstr.h:110
#define MERF_SPLITMASK
Definition: editstr.h:135

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

◆ WINE_DECLARE_DEBUG_CHANNEL() [1/2]

WINE_DECLARE_DEBUG_CHANNEL ( richedit_check  )

◆ WINE_DECLARE_DEBUG_CHANNEL() [2/2]

WINE_DECLARE_DEBUG_CHANNEL ( richedit_lists  )

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( richedit  )