1 /*
2 * RichEdit - Basic operations on double linked lists.
3 *
4 * Copyright 2004 by Krzysztof Foltman
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21
22 #include "editor.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(richedit_lists);
25
26 void ME_InsertBefore(ME_DisplayItem *diWhere, ME_DisplayItem *diWhat)
27 {
28 diWhat->next = diWhere;
29 diWhat->prev = diWhere->prev;
30
31 diWhere->prev->next = diWhat;
32 diWhat->next->prev = diWhat;
33 }
34
35 void ME_Remove(ME_DisplayItem *diWhere)
36 {
37 ME_DisplayItem *diNext = diWhere->next;
38 ME_DisplayItem *diPrev = diWhere->prev;
39 assert(diNext);
40 assert(diPrev);
41 diPrev->next = diNext;
42 diNext->prev = diPrev;
43 }
44
45 static BOOL ME_DITypesEqual(ME_DIType type, ME_DIType nTypeOrClass)
46 {
47 switch (nTypeOrClass)
48 {
49 case diRunOrParagraph:
50 return type == diRun || type == diParagraph;
51 case diRunOrStartRow:
52 return type == diRun || type == diStartRow;
53 case diParagraphOrEnd:
54 return type == diTextEnd || type == diParagraph;
55 case diStartRowOrParagraph:
56 return type == diStartRow || type == diParagraph;
57 case diStartRowOrParagraphOrEnd:
58 return type == diStartRow || type == diParagraph || type == diTextEnd;
59 case diRunOrParagraphOrEnd:
60 return type == diRun || type == diParagraph || type == diTextEnd;
61 default:
62 return type == nTypeOrClass;
63 }
64 }
65
66 /* Modifies run pointer to point to the next run, and modify the
67 * paragraph pointer if moving into the next paragraph.
68 *
69 * Returns TRUE if next run is found, otherwise returns FALSE. */
70 BOOL ME_NextRun(ME_DisplayItem **para, ME_DisplayItem **run)
71 {
72 ME_DisplayItem *p = (*run)->next;
73 while (p->type != diTextEnd)
74 {
75 if (p->type == diParagraph) {
76 *para = p;
77 } else if (p->type == diRun) {
78 *run = p;
79 return TRUE;
80 }
81 p = p->next;
82 }
83 return FALSE;
84 }
85
86 /* Modifies run pointer to point to the previous run, and modify the
87 * paragraph pointer if moving into the previous paragraph.
88 *
89 * Returns TRUE if previous run is found, otherwise returns FALSE. */
90 BOOL ME_PrevRun(ME_DisplayItem **para, ME_DisplayItem **run)
91 {
92 ME_DisplayItem *p = (*run)->prev;
93 while (p->type != diTextStart)
94 {
95 if (p->type == diParagraph) {
96 if (p->member.para.prev_para->type == diParagraph)
97 *para = p->member.para.prev_para;
98 } else if (p->type == diRun) {
99 *run = p;
100 return TRUE;
101 }
102 p = p->prev;
103 }
104 return FALSE;
105 }
106
107 ME_DisplayItem *ME_FindItemBack(ME_DisplayItem *di, ME_DIType nTypeOrClass)
108 {
109 if (!di)
110 return NULL;
111 di = di->prev;
112 while(di!=NULL) {
113 if (ME_DITypesEqual(di->type, nTypeOrClass))
114 return di;
115 di = di->prev;
116 }
117 return NULL;
118 }
119
120 ME_DisplayItem *ME_FindItemBackOrHere(ME_DisplayItem *di, ME_DIType nTypeOrClass)
121 {
122 while(di!=NULL) {
123 if (ME_DITypesEqual(di->type, nTypeOrClass))
124 return di;
125 di = di->prev;
126 }
127 return NULL;
128 }
129
130 ME_DisplayItem *ME_FindItemFwd(ME_DisplayItem *di, ME_DIType nTypeOrClass)
131 {
132 if (!di) return NULL;
133 di = di->next;
134 while(di!=NULL) {
135 if (ME_DITypesEqual(di->type, nTypeOrClass))
136 return di;
137 di = di->next;
138 }
139 return NULL;
140 }
141
142 void ME_DestroyDisplayItem(ME_DisplayItem *item) {
143 /* TRACE("type=%s\n", ME_GetDITypeName(item->type)); */
144 if (item->type==diParagraph || item->type == diUndoSetParagraphFormat) {
145 FREE_OBJ(item->member.para.pFmt);
146 }
147 if (item->type==diRun || item->type == diUndoInsertRun) {
148 if (item->member.run.ole_obj) ME_DeleteReObject(item->member.run.ole_obj);
149 ME_ReleaseStyle(item->member.run.style);
150 ME_DestroyString(item->member.run.strText);
151 }
152 if (item->type==diUndoSetCharFormat) {
153 ME_ReleaseStyle(item->member.ustyle);
154 }
155 if (item->type==diUndoSplitParagraph) {
156 FREE_OBJ(item->member.para.pFmt);
157 FREE_OBJ(item->member.para.pCell);
158 }
159 FREE_OBJ(item);
160 }
161
162 ME_DisplayItem *ME_MakeDI(ME_DIType type) {
163 ME_DisplayItem *item = ALLOC_OBJ(ME_DisplayItem);
164 ZeroMemory(item, sizeof(ME_DisplayItem));
165 item->type = type;
166 item->prev = item->next = NULL;
167 if (type == diParagraph || type == diUndoSplitParagraph) {
168 item->member.para.pFmt = ALLOC_OBJ(PARAFORMAT2);
169 ME_SetDefaultParaFormat(item->member.para.pFmt);
170 item->member.para.nFlags = MEPF_REWRAP;
171 }
172
173 return item;
174 }
175
176 const char *ME_GetDITypeName(ME_DIType type)
177 {
178 switch(type)
179 {
180 case diParagraph: return "diParagraph";
181 case diRun: return "diRun";
182 case diCell: return "diCell";
183 case diTextStart: return "diTextStart";
184 case diTextEnd: return "diTextEnd";
185 case diStartRow: return "diStartRow";
186 case diUndoEndTransaction: return "diUndoEndTransaction";
187 case diUndoPotentialEndTransaction: return "diUndoPotentialEndTransaction";
188 case diUndoSetParagraphFormat: return "diUndoSetParagraphFormat";
189 case diUndoSetCharFormat: return "diUndoSetCharFormat";
190 case diUndoInsertRun: return "diUndoInsertRun";
191 case diUndoDeleteRun: return "diUndoDeleteRun";
192 case diUndoJoinParagraphs: return "diJoinParagraphs";
193 case diUndoSplitParagraph: return "diSplitParagraph";
194 default: return "?";
195 }
196 }
197
198 void ME_DumpDocument(ME_TextBuffer *buffer)
199 {
200 /* FIXME this is useless, */
201 ME_DisplayItem *pItem = buffer->pFirst;
202 TRACE("DOCUMENT DUMP START\n");
203 while(pItem) {
204 switch(pItem->type)
205 {
206 case diTextStart:
207 TRACE("Start\n");
208 break;
209 case diCell:
210 TRACE("Cell(level=%d%s)\n", pItem->member.cell.nNestingLevel,
211 !pItem->member.cell.next_cell ? ", END" :
212 (!pItem->member.cell.prev_cell ? ", START" :""));
213 break;
214 case diParagraph:
215 TRACE("Paragraph(ofs=%d)\n", pItem->member.para.nCharOfs);
216 if (pItem->member.para.nFlags & MEPF_ROWSTART)
217 TRACE(" - (Table Row Start)\n");
218 if (pItem->member.para.nFlags & MEPF_ROWEND)
219 TRACE(" - (Table Row End)\n");
220 break;
221 case diStartRow:
222 TRACE(" - StartRow\n");
223 break;
224 case diRun:
225 TRACE(" - Run(\"%s\", %d, flags=%x)\n", debugstr_w(pItem->member.run.strText->szData),
226 pItem->member.run.nCharOfs, pItem->member.run.nFlags);
227 break;
228 case diTextEnd:
229 TRACE("End(ofs=%d)\n", pItem->member.para.nCharOfs);
230 break;
231 default:
232 break;
233 }
234 pItem = pItem->next;
235 }
236 TRACE("DOCUMENT DUMP END\n");
237 }
238
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.