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
ME_InsertBefore(ME_DisplayItem * diWhere,ME_DisplayItem * diWhat)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
ME_Remove(ME_DisplayItem * diWhere)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
ME_DITypesEqual(ME_DIType type,ME_DIType nTypeOrClass)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.
67 * If all_para is FALSE constrain the search to the current para,
68 * otherwise modify the paragraph pointer if moving into the next paragraph.
69 *
70 * Returns TRUE if next run is found, otherwise returns FALSE. */
ME_NextRun(ME_DisplayItem ** para,ME_DisplayItem ** run,BOOL all_para)71 BOOL ME_NextRun(ME_DisplayItem **para, ME_DisplayItem **run, BOOL all_para)
72 {
73 ME_DisplayItem *p = (*run)->next;
74 while (p->type != diTextEnd)
75 {
76 if (p->type == diParagraph) {
77 if (!all_para) return FALSE;
78 *para = p;
79 } else if (p->type == diRun) {
80 *run = p;
81 return TRUE;
82 }
83 p = p->next;
84 }
85 return FALSE;
86 }
87
88 /* Modifies run pointer to point to the previous run.
89 * If all_para is FALSE constrain the search to the current para,
90 * otherwise modify the paragraph pointer if moving into the previous paragraph.
91 *
92 * Returns TRUE if previous run is found, otherwise returns FALSE. */
ME_PrevRun(ME_DisplayItem ** para,ME_DisplayItem ** run,BOOL all_para)93 BOOL ME_PrevRun(ME_DisplayItem **para, ME_DisplayItem **run, BOOL all_para)
94 {
95 ME_DisplayItem *p = (*run)->prev;
96 while (p->type != diTextStart)
97 {
98 if (p->type == diParagraph) {
99 if (!all_para) return FALSE;
100 if (para && p->member.para.prev_para->type == diParagraph)
101 *para = p->member.para.prev_para;
102 } else if (p->type == diRun) {
103 *run = p;
104 return TRUE;
105 }
106 p = p->prev;
107 }
108 return FALSE;
109 }
110
ME_FindItemBack(ME_DisplayItem * di,ME_DIType nTypeOrClass)111 ME_DisplayItem *ME_FindItemBack(ME_DisplayItem *di, ME_DIType nTypeOrClass)
112 {
113 if (!di)
114 return NULL;
115 di = di->prev;
116 while(di!=NULL) {
117 if (ME_DITypesEqual(di->type, nTypeOrClass))
118 return di;
119 di = di->prev;
120 }
121 return NULL;
122 }
123
ME_FindItemBackOrHere(ME_DisplayItem * di,ME_DIType nTypeOrClass)124 ME_DisplayItem *ME_FindItemBackOrHere(ME_DisplayItem *di, ME_DIType nTypeOrClass)
125 {
126 while(di!=NULL) {
127 if (ME_DITypesEqual(di->type, nTypeOrClass))
128 return di;
129 di = di->prev;
130 }
131 return NULL;
132 }
133
ME_FindItemFwd(ME_DisplayItem * di,ME_DIType nTypeOrClass)134 ME_DisplayItem *ME_FindItemFwd(ME_DisplayItem *di, ME_DIType nTypeOrClass)
135 {
136 if (!di) return NULL;
137 di = di->next;
138 while(di!=NULL) {
139 if (ME_DITypesEqual(di->type, nTypeOrClass))
140 return di;
141 di = di->next;
142 }
143 return NULL;
144 }
145
ME_GetDITypeName(ME_DIType type)146 static const char *ME_GetDITypeName(ME_DIType type)
147 {
148 switch(type)
149 {
150 case diParagraph: return "diParagraph";
151 case diRun: return "diRun";
152 case diCell: return "diCell";
153 case diTextStart: return "diTextStart";
154 case diTextEnd: return "diTextEnd";
155 case diStartRow: return "diStartRow";
156 default: return "?";
157 }
158 }
159
ME_DestroyDisplayItem(ME_DisplayItem * item)160 void ME_DestroyDisplayItem(ME_DisplayItem *item)
161 {
162 if (0)
163 TRACE("type=%s\n", ME_GetDITypeName(item->type));
164 if (item->type==diRun)
165 {
166 if (item->member.run.reobj)
167 {
168 list_remove(&item->member.run.reobj->entry);
169 ME_DeleteReObject(item->member.run.reobj);
170 }
171 heap_free( item->member.run.glyphs );
172 heap_free( item->member.run.clusters );
173 ME_ReleaseStyle(item->member.run.style);
174 }
175 heap_free(item);
176 }
177
ME_MakeDI(ME_DIType type)178 ME_DisplayItem *ME_MakeDI(ME_DIType type)
179 {
180 ME_DisplayItem *item = heap_alloc_zero(sizeof(*item));
181
182 item->type = type;
183 item->prev = item->next = NULL;
184 return item;
185 }
186
ME_DumpDocument(ME_TextBuffer * buffer)187 void ME_DumpDocument(ME_TextBuffer *buffer)
188 {
189 /* FIXME this is useless, */
190 ME_DisplayItem *pItem = buffer->pFirst;
191 TRACE("DOCUMENT DUMP START\n");
192 while(pItem) {
193 switch(pItem->type)
194 {
195 case diTextStart:
196 TRACE("Start\n");
197 break;
198 case diCell:
199 TRACE("Cell(level=%d%s)\n", pItem->member.cell.nNestingLevel,
200 !pItem->member.cell.next_cell ? ", END" :
201 (!pItem->member.cell.prev_cell ? ", START" :""));
202 break;
203 case diParagraph:
204 TRACE("Paragraph(ofs=%d)\n", pItem->member.para.nCharOfs);
205 if (pItem->member.para.nFlags & MEPF_ROWSTART)
206 TRACE(" - (Table Row Start)\n");
207 if (pItem->member.para.nFlags & MEPF_ROWEND)
208 TRACE(" - (Table Row End)\n");
209 break;
210 case diStartRow:
211 TRACE(" - StartRow\n");
212 break;
213 case diRun:
214 TRACE(" - Run(%s, %d, flags=%x)\n", debugstr_run( &pItem->member.run ),
215 pItem->member.run.nCharOfs, pItem->member.run.nFlags);
216 break;
217 case diTextEnd:
218 TRACE("End(ofs=%d)\n", pItem->member.para.nCharOfs);
219 break;
220 default:
221 break;
222 }
223 pItem = pItem->next;
224 }
225 TRACE("DOCUMENT DUMP END\n");
226 }
227