huwcampbell.com
Reactos
1/*
2 * RichEdit - string operations
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#include "editor.h"
22
23WINE_DEFAULT_DEBUG_CHANNEL(richedit);
24
25static int ME_GetOptimalBuffer(int nLen)
26{
27 return ((sizeof(WCHAR) * nLen) + 128) & ~63;
28}
29
30static ME_String *make_string( void (*free)(ME_String *) )
31{
32 ME_String *s = malloc( sizeof(*s) );
33
34 if (s) s->free = free;
35 return s;
36}
37
38/* Create a ME_String using the const string provided.
39 * str must exist for the lifetime of the returned ME_String.
40 */
41ME_String *ME_MakeStringConst(const WCHAR *str, int len)
42{
43 ME_String *s = make_string( NULL );
44 if (!s) return NULL;
45
46 s->szData = (WCHAR *)str;
47 s->nLen = len;
48 s->nBuffer = 0;
49 return s;
50}
51
52static void string_free(ME_String *s)
53{
54 free( s->szData );
55}
56
57/* Create a buffer (uninitialized string) of size nMaxChars */
58ME_String *ME_MakeStringEmpty(int nMaxChars)
59{
60 ME_String *s = make_string( string_free );
61
62 if (!s) return NULL;
63 s->nLen = nMaxChars;
64 s->nBuffer = ME_GetOptimalBuffer(s->nLen + 1);
65 s->szData = malloc( s->nBuffer * sizeof(WCHAR) );
66 if (!s->szData)
67 {
68 free( s );
69 return NULL;
70 }
71 s->szData[s->nLen] = 0;
72 return s;
73}
74
75ME_String *ME_MakeStringN(LPCWSTR szText, int nMaxChars)
76{
77 ME_String *s = ME_MakeStringEmpty(nMaxChars);
78
79 if (!s) return NULL;
80 memcpy(s->szData, szText, s->nLen * sizeof(WCHAR));
81 return s;
82}
83
84/* Make a string by repeating a char nMaxChars times */
85ME_String *ME_MakeStringR(WCHAR cRepeat, int nMaxChars)
86{
87 int i;
88 ME_String *s = ME_MakeStringEmpty(nMaxChars);
89
90 if (!s) return NULL;
91 for (i = 0; i < nMaxChars; i++)
92 s->szData[i] = cRepeat;
93 return s;
94}
95
96void ME_DestroyString(ME_String *s)
97{
98 if (!s) return;
99 if (s->free) s->free( s );
100 free( s );
101}
102
103BOOL ME_InsertString(ME_String *s, int ofs, const WCHAR *insert, int len)
104{
105 DWORD new_len = s->nLen + len + 1;
106 WCHAR *new;
107
108 assert( s->nBuffer ); /* Not a const string */
109 assert( ofs <= s->nLen );
110
111 if( new_len > s->nBuffer )
112 {
113 s->nBuffer = ME_GetOptimalBuffer( new_len );
114 new = realloc( s->szData, s->nBuffer * sizeof(WCHAR) );
115 if (!new) return FALSE;
116 s->szData = new;
117 }
118
119 memmove( s->szData + ofs + len, s->szData + ofs, (s->nLen - ofs + 1) * sizeof(WCHAR) );
120 memcpy( s->szData + ofs, insert, len * sizeof(WCHAR) );
121 s->nLen += len;
122
123 return TRUE;
124}
125
126BOOL ME_AppendString(ME_String *s, const WCHAR *append, int len)
127{
128 return ME_InsertString( s, s->nLen, append, len );
129}
130
131ME_String *ME_VSplitString(ME_String *orig, int charidx)
132{
133 ME_String *s;
134
135 assert(orig->nBuffer); /* Not a const string */
136 assert(charidx>=0);
137 assert(charidx<=orig->nLen);
138
139 s = ME_MakeStringN(orig->szData+charidx, orig->nLen-charidx);
140 if (!s) return NULL;
141
142 orig->nLen = charidx;
143 orig->szData[charidx] = '\0';
144 return s;
145}
146
147void ME_StrDeleteV(ME_String *s, int nVChar, int nChars)
148{
149 int end_ofs = nVChar + nChars;
150
151 assert(s->nBuffer); /* Not a const string */
152 assert(nChars >= 0);
153 assert(nVChar >= 0);
154 assert(end_ofs <= s->nLen);
155
156 memmove(s->szData + nVChar, s->szData + end_ofs,
157 (s->nLen - end_ofs + 1) * sizeof(WCHAR));
158 s->nLen -= nChars;
159}
160
161static int
162ME_WordBreakProc(LPWSTR s, INT start, INT len, INT code)
163{
164#ifndef __REACTOS__
165 /* FIXME: Native also knows about punctuation */
166#endif
167 TRACE("s==%s, start==%d, len==%d, code==%d\n",
168 debugstr_wn(s, len), start, len, code);
169
170 switch (code)
171 {
172 case WB_ISDELIMITER:
173 return ME_IsWSpace(s[start]);
174 case WB_LEFT:
175 case WB_MOVEWORDLEFT:
176 while (start && ME_IsWSpace(s[start - 1]))
177 start--;
178#ifdef __REACTOS__
179 while (start && !ME_IsWSpace(s[start - 1]) && !iswpunct(s[start - 1]))
180 start--;
181#else
182 while (start && !ME_IsWSpace(s[start - 1]))
183 start--;
184#endif
185 return start;
186 case WB_RIGHT:
187 case WB_MOVEWORDRIGHT:
188#ifdef __REACTOS__
189 while (start < len && !ME_IsWSpace(s[start]) && !iswpunct(s[start]))
190 start++;
191#else
192 while (start < len && !ME_IsWSpace(s[start]))
193 start++;
194#endif
195 while (start < len && ME_IsWSpace(s[start]))
196 start++;
197 return start;
198 }
199 return 0;
200}
201
202
203int
204ME_CallWordBreakProc(ME_TextEditor *editor, WCHAR *str, INT len, INT start, INT code)
205{
206 if (!editor->pfnWordBreak) {
207 return ME_WordBreakProc(str, start, len, code);
208 } else if (!editor->bEmulateVersion10) {
209 /* MSDN lied about the third parameter for EditWordBreakProc being the number
210 * of characters, it is actually the number of bytes of the string. */
211 return editor->pfnWordBreak(str, start, len * sizeof(WCHAR), code);
212 } else {
213 int result;
214 int buffer_size = WideCharToMultiByte(CP_ACP, 0, str, len,
215 NULL, 0, NULL, NULL);
216 char *buffer = malloc(buffer_size);
217 if (!buffer) return 0;
218 WideCharToMultiByte(CP_ACP, 0, str, len,
219 buffer, buffer_size, NULL, NULL);
220 result = editor->pfnWordBreak((WCHAR*)buffer, start, buffer_size, code);
221 free(buffer);
222 return result;
223 }
224}
225
226LPWSTR ME_ToUnicode(LONG codepage, LPVOID psz, INT *len)
227{
228 *len = 0;
229 if (!psz) return NULL;
230
231 if (codepage == CP_UNICODE)
232 {
233 *len = lstrlenW(psz);
234 return psz;
235 }
236 else {
237 WCHAR *tmp;
238 int nChars = MultiByteToWideChar(codepage, 0, psz, -1, NULL, 0);
239
240 if(!nChars) return NULL;
241
242 if((tmp = malloc(nChars * sizeof(WCHAR))) != NULL)
243 *len = MultiByteToWideChar(codepage, 0, psz, -1, tmp, nChars) - 1;
244 return tmp;
245 }
246}
247
248void ME_EndToUnicode(LONG codepage, LPVOID psz)
249{
250 if (codepage != CP_UNICODE)
251 free(psz);
252}