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 ME_DisplayItem *ME_FindItemBack(ME_DisplayItem *di, ME_DIType nTypeOrClass)
46 {
47 if (!di)
48 return NULL;
49 di = di->prev;
50 while(di!=NULL) {
51 if (ME_DITypesEqual(di->type, nTypeOrClass))
52 return di;
53 di = di->prev;
54 }
55 return NULL;
56 }
57
58 ME_DisplayItem *ME_FindItemBackOrHere(ME_DisplayItem *di, ME_DIType nTypeOrClass)
59 {
60 while(di!=NULL) {
61 if (ME_DITypesEqual(di->type, nTypeOrClass))
62 return di;
63 di = di->prev;
64 }
65 return NULL;
66 }
67
68 ME_DisplayItem *ME_FindItemFwd(ME_DisplayItem *di, ME_DIType nTypeOrClass)
69 {
70 if (!di) return NULL;
71 di = di->next;
72 while(di!=NULL) {
73 if (ME_DITypesEqual(di->type, nTypeOrClass))
74 return di;
75 di = di->next;
76 }
77 return NULL;
78 }
79
80 ME_DisplayItem *ME_FindItemFwdOrHere(ME_DisplayItem *di, ME_DIType nTypeOrClass)
81 {
82 while(di!=NULL) {
83 if (ME_DITypesEqual(di->type, nTypeOrClass))
84 return di;
85 di = di->next;
86 }
87 return NULL;
88 }
89
90 BOOL ME_DITypesEqual(ME_DIType type, ME_DIType nTypeOrClass)
91 {
92 if (type==nTypeOrClass)
93 return TRUE;
94 if (nTypeOrClass==diRunOrParagraph && (type==diRun || type==diParagraph))
95 return TRUE;
96 if (nTypeOrClass==diRunOrStartRow && (type==diRun || type==diStartRow))
97 return TRUE;
98 if (nTypeOrClass==diParagraphOrEnd && (type==diTextEnd || type==diParagraph))
99 return TRUE;
100 if (nTypeOrClass==diStartRowOrParagraph && (type==diStartRow || type==diParagraph))
101 return TRUE;
102 if (nTypeOrClass==diStartRowOrParagraphOrEnd
103 && (type==diStartRow || type==diParagraph || type==diTextEnd))
104 return TRUE;
105 if (nTypeOrClass==diRunOrParagraphOrEnd
106 && (type==diRun || type==diParagraph || type==diTextEnd))
107 return TRUE;
108 return FALSE;
109 }
110
111 void ME_DestroyDisplayItem(ME_DisplayItem *item) {
112 /* TRACE("type=%s\n", ME_GetDITypeName(item->type)); */
113 if (item->type==diParagraph || item->type == diUndoSetParagraphFormat) {
114 FREE_OBJ(item->member.para.pFmt);
115 ME_DestroyTableCellList(item);
116 }
117 if (item->type==diRun || item->type == diUndoInsertRun) {
118 if (item->member.run.ole_obj) ME_DeleteReObject(item->member.run.ole_obj);
119 ME_ReleaseStyle(item->member.run.style);
120 ME_DestroyString(item->member.run.strText);
121 }
122 if (item->type==diUndoSetCharFormat || item->type==diUndoSetDefaultCharFormat) {
123 ME_ReleaseStyle(item->member.ustyle);
124 }
125 if (item->type==diUndoSplitParagraph)
126 FREE_OBJ(item->member.para.pFmt);
127 FREE_OBJ(item);
128 }
129
130 void
131 ME_DestroyTableCellList(ME_DisplayItem *item)
132 {
133 if (item->member.para.pCells)
134 {
135 ME_TableCell *pCell = item->member.para.pCells;
136 ME_TableCell *pNext;
137
138 while (pCell) {
139 pNext = pCell->next;
140 FREE_OBJ(pCell);
141 pCell = pNext;
142 }
143 item->member.para.pCells = NULL;
144 }
145 }
146
147 ME_DisplayItem *ME_MakeDI(ME_DIType type) {
148 ME_DisplayItem *item = ALLOC_OBJ(ME_DisplayItem);
149 ZeroMemory(item, sizeof(ME_DisplayItem));
150 item->type = type;
151 item->prev = item->next = NULL;
152 if (type == diParagraph || type == diUndoSplitParagraph) {
153 item->member.para.pFmt = ALLOC_OBJ(PARAFORMAT2);
154 item->member.para.pFmt->cbSize = sizeof(PARAFORMAT2);
155 item->member.para.pFmt->dwMask = 0;
156 item->member.para.nFlags = MEPF_REWRAP;
157 }
158
159 return item;
160 }
161
162 const char *ME_GetDITypeName(ME_DIType type)
163 {
164 switch(type)
165 {
166 case diParagraph: return "diParagraph";
167 case diRun: return "diRun";
168 case diTextStart: return "diTextStart";
169 case diTextEnd: return "diTextEnd";
170 case diStartRow: return "diStartRow";
171 case diUndoEndTransaction: return "diUndoEndTransaction";
172 case diUndoSetParagraphFormat: return "diUndoSetParagraphFormat";
173 case diUndoSetCharFormat: return "diUndoSetCharFormat";
174 case diUndoInsertRun: return "diUndoInsertRun";
175 case diUndoDeleteRun: return "diUndoDeleteRun";
176 case diUndoJoinParagraphs: return "diJoinParagraphs";
177 case diUndoSplitParagraph: return "diSplitParagraph";
178 case diUndoSetDefaultCharFormat: return "diUndoSetDefaultCharFormat";
179 default: return "?";
180 }
181 }
182
183 void ME_DumpDocument(ME_TextBuffer *buffer)
184 {
185 /* FIXME this is useless, */
186 ME_DisplayItem *pItem = buffer->pFirst;
187 TRACE("DOCUMENT DUMP START\n");
188 while(pItem) {
189 switch(pItem->type)
190 {
191 case diTextStart:
192 TRACE("Start\n");
193 break;
194 case diParagraph:
195 TRACE("Paragraph(ofs=%d)\n", pItem->member.para.nCharOfs);
196 break;
197 case diStartRow:
198 TRACE(" - StartRow\n");
199 break;
200 case diRun:
201 TRACE(" - Run(\"%s\", %d)\n", debugstr_w(pItem->member.run.strText->szData),
202 pItem->member.run.nCharOfs);
203 if (pItem->member.run.nFlags & MERF_ENDPARA)
204 TRACE(" - Paragraph end: %d CR, %d LF\n", pItem->member.run.nCR, pItem->member.run.nLF);
205 break;
206 case diTextEnd:
207 TRACE("End(ofs=%d)\n", pItem->member.para.nCharOfs);
208 break;
209 default:
210 break;
211 }
212 pItem = pItem->next;
213 }
214 TRACE("DOCUMENT DUMP END\n");
215 }
216
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.