?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
quartz: Remove dead code from DSoundRender.
[wine/wine64.git] / dlls / mlang / mlang.c
blob2f73f1f71a6219715ef6b1c2a03ec866c9df7a72
1 /*
2 * MLANG Class Factory
3 *
4 * Copyright 2002 Lionel Ulmer
5 * Copyright 2003,2004 Mike McCormack
6 * Copyright 2004,2005 Dmitry Timoshkov
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24
25 #include <stdarg.h>
26 #include <stdio.h>
27
28 #define COBJMACROS
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "ole2.h"
35 #include "mlang.h"
36
37 #include "wine/unicode.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(mlang);
41
42 #include "initguid.h"
43
44 #define CP_UNICODE 1200
45
46 #define ICOM_THIS_MULTI(impl,field,iface) impl* const This=(impl*)((char*)(iface) - offsetof(impl,field))
47
48 static HRESULT MultiLanguage_create(IUnknown *pUnkOuter, LPVOID *ppObj);
49 static HRESULT EnumRfc1766_create(LANGID LangId, IEnumRfc1766 **ppEnum);
50
51 static DWORD MLANG_tls_index; /* to store various per thead data */
52
53 /* FIXME:
54 * Under what circumstances HKEY_CLASSES_ROOT\MIME\Database\Codepage and
55 * HKEY_CLASSES_ROOT\MIME\Database\Charset are used?
56 */
57
58 typedef struct
59 {
60 const char *description;
61 UINT cp;
62 DWORD flags;
63 const char *web_charset;
64 const char *header_charset;
65 const char *body_charset;
66 } MIME_CP_INFO;
67
68 /* These data are based on the codepage info in libs/unicode/cpmap.pl */
69 /* FIXME: Add 28604 (Celtic), 28606 (Balkan) */
70
71 static const MIME_CP_INFO arabic_cp[] =
72 {
73 { "Arabic (864)",
74 864, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
75 MIMECONTF_MIME_LATEST,
76 "ibm864", "ibm864", "ibm864" },
77 { "Arabic (1006)",
78 1006, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
79 MIMECONTF_MIME_LATEST,
80 "ibm1006", "ibm1006", "ibm1006" },
81 { "Arabic (Windows)",
82 1256, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
83 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
84 MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
85 "windows-1256", "windows-1256", "windows-1256" },
86 { "Arabic (ISO)",
87 28596, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
88 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
89 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
90 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
91 "iso-8859-6", "iso-8859-6", "iso-8859-6" }
92 };
93 static const MIME_CP_INFO baltic_cp[] =
94 {
95 { "Baltic (DOS)",
96 775, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
97 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
98 "ibm775", "ibm775", "ibm775" },
99 { "Baltic (Windows)",
100 1257, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
101 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
102 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
103 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
104 "windows-1257", "windows-1257", "windows-1257" },
105 { "Baltic (ISO)",
106 28594, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
107 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
108 MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
109 MIMECONTF_MIME_LATEST,
110 "iso-8859-4", "iso-8859-4", "iso-8859-4" },
111 { "Estonian (ISO)",
112 28603, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
113 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
114 "iso-8859-13", "iso-8859-13", "iso-8859-13" }
115 };
116 static const MIME_CP_INFO chinese_simplified_cp[] =
117 {
118 { "Chinese Simplified (GB2312)",
119 936, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
120 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
121 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
122 MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
123 "gb2312", "gb2312", "gb2312" }
124 };
125 static const MIME_CP_INFO chinese_traditional_cp[] =
126 {
127 { "Chinese Traditional (Big5)",
128 950, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
129 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
130 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
131 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
132 "big5", "big5", "big5" }
133 };
134 static const MIME_CP_INFO central_european_cp[] =
135 {
136 { "Central European (DOS)",
137 852, MIMECONTF_BROWSER | MIMECONTF_IMPORT | MIMECONTF_SAVABLE_BROWSER |
138 MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
139 MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
140 "ibm852", "ibm852", "ibm852" },
141 { "Central European (Windows)",
142 1250, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
143 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
144 MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
145 MIMECONTF_MIME_LATEST,
146 "windows-1250", "windows-1250", "windows-1250" },
147 { "Central European (Mac)",
148 10029, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
149 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
150 "x-mac-ce", "x-mac-ce", "x-mac-ce" },
151 { "Central European (ISO)",
152 28592, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
153 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
154 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
155 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
156 "iso-8859-2", "iso-8859-2", "iso-8859-2" }
157 };
158 static const MIME_CP_INFO cyrillic_cp[] =
159 {
160 { "OEM Cyrillic",
161 855, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
162 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
163 "ibm855", "ibm855", "ibm855" },
164 { "Cyrillic (DOS)",
165 866, MIMECONTF_BROWSER | MIMECONTF_IMPORT | MIMECONTF_SAVABLE_BROWSER |
166 MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 |
167 MIMECONTF_MIME_LATEST,
168 "cp866", "cp866", "cp866" },
169 #if 0 /* Windows has 20866 as an official code page for KOI8-R */
170 { "Cyrillic (KOI8-R)",
171 878, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
172 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
173 "koi8-r", "koi8-r", "koi8-r" },
174 #endif
175 { "Cyrillic (Windows)",
176 1251, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
177 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
178 MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
179 "windows-1251", "windows-1251", "windows-1251" },
180 { "Cyrillic (Mac)",
181 10007, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
182 MIMECONTF_MIME_LATEST,
183 "x-mac-cyrillic", "x-mac-cyrillic", "x-mac-cyrillic" },
184 { "Cyrillic (KOI8-R)",
185 20866, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
186 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
187 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
188 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
189 "koi8-r", "koi8-r", "koi8-r" },
190 { "Cyrillic (KOI8-U)",
191 21866, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
192 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
193 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
194 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
195 "koi8-u", "koi8-u", "koi8-u" },
196 { "Cyrillic (ISO)",
197 28595, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
198 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
199 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
200 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
201 "iso-8859-5", "iso-8859-5", "iso-8859-5" }
202 };
203 static const MIME_CP_INFO greek_cp[] =
204 {
205 { "Greek (DOS)",
206 737, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
207 MIMECONTF_MIME_LATEST,
208 "ibm737", "ibm737", "ibm737" },
209 { "Greek, Modern (DOS)",
210 869, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
211 MIMECONTF_MIME_LATEST,
212 "ibm869", "ibm869", "ibm869" },
213 { "IBM EBCDIC (Greek Modern)",
214 875, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
215 MIMECONTF_MIME_LATEST,
216 "cp875", "cp875", "cp875" },
217 { "Greek (Windows)",
218 1253, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
219 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
220 MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
221 "windows-1253", "windows-1253", "windows-1253" },
222 { "Greek (Mac)",
223 10006, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
224 MIMECONTF_MIME_LATEST,
225 "x-mac-greek", "x-mac-greek", "x-mac-greek" },
226 { "Greek (ISO)",
227 28597, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
228 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
229 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
230 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
231 "iso-8859-7", "iso-8859-7", "iso-8859-7" }
232 };
233 static const MIME_CP_INFO hebrew_cp[] =
234 {
235 { "Hebrew (424)",
236 424, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
237 MIMECONTF_MIME_LATEST,
238 "ibm424", "ibm424", "ibm424" },
239 { "Hebrew (856)",
240 856, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
241 MIMECONTF_MIME_LATEST,
242 "cp856", "cp856", "cp856" },
243 { "Hebrew (DOS)",
244 862, MIMECONTF_BROWSER | MIMECONTF_MINIMAL | MIMECONTF_IMPORT |
245 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
246 MIMECONTF_MIME_LATEST,
247 "dos-862", "dos-862", "dos-862" },
248 { "Hebrew (Windows)",
249 1255, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
250 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
251 MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
252 "windows-1255", "windows-1255", "windows-1255" },
253 { "Hebrew (ISO-Visual)",
254 28598, MIMECONTF_BROWSER | MIMECONTF_MINIMAL | MIMECONTF_IMPORT |
255 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
256 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
257 "iso-8859-8", "iso-8859-8", "iso-8859-8" }
258 };
259 static const MIME_CP_INFO japanese_cp[] =
260 {
261 { "Japanese (Shift-JIS)",
262 932, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
263 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
264 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
265 MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
266 "shift_jis", "iso-2022-jp", "iso-2022-jp" },
267 { "Japanese (JIS 0208-1990 and 0212-1990)",
268 20932, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
269 MIMECONTF_MIME_LATEST,
270 "euc-jp", "euc-jp", "euc-jp" }
271 };
272 static const MIME_CP_INFO korean_cp[] =
273 {
274 { "Korean",
275 949, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
276 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
277 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
278 MIMECONTF_MIME_LATEST,
279 "ks_c_5601-1987", "ks_c_5601-1987", "ks_c_5601-1987" }
280 };
281 static const MIME_CP_INFO thai_cp[] =
282 {
283 { "Thai (Windows)",
284 874, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_MIME_LATEST,
285 "ibm-thai", "ibm-thai", "ibm-thai" }
286 };
287 static const MIME_CP_INFO turkish_cp[] =
288 {
289 { "Turkish (DOS)",
290 857, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
291 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
292 "ibm857", "ibm857", "ibm857" },
293 { "IBM EBCDIC (Turkish Latin-5)",
294 1026, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
295 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
296 "ibm1026", "ibm1026", "ibm1026" },
297 { "Turkish (Windows)",
298 1254, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
299 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
300 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
301 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
302 "windows-1254", "windows-1254", "windows-1254" },
303 { "Turkish (Mac)",
304 10081, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
305 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
306 "x-mac-turkish", "x-mac-turkish", "x-mac-turkish" },
307 { "Latin 3 (ISO)",
308 28593, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT |
309 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_EXPORT | MIMECONTF_VALID |
310 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
311 "iso-8859-3", "iso-8859-3", "iso-8859-3" },
312 { "Turkish (ISO)",
313 28599, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
314 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
315 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
316 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
317 "iso-8859-9", "iso-8859-9", "iso-8859-9" }
318 };
319 static const MIME_CP_INFO vietnamese_cp[] =
320 {
321 { "Vietnamese (Windows)",
322 1258, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
323 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
324 MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 |
325 MIMECONTF_MIME_LATEST,
326 "windows-1258", "windows-1258", "windows-1258" }
327 };
328 static const MIME_CP_INFO western_cp[] =
329 {
330 { "IBM EBCDIC (US-Canada)",
331 37, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
332 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
333 "ibm037", "ibm037", "ibm037" },
334 { "OEM United States",
335 437, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
336 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
337 "ibm437", "ibm437", "ibm437" },
338 { "IBM EBCDIC (International)",
339 500, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
340 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
341 "ibm500", "ibm500", "ibm500" },
342 { "Western European (DOS)",
343 850, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
344 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
345 "ibm850", "ibm850", "ibm850" },
346 { "Portuguese (DOS)",
347 860, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
348 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
349 "ibm860", "ibm860", "ibm860" },
350 { "Icelandic (DOS)",
351 861, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
352 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
353 "ibm861", "ibm861", "ibm861" },
354 { "French Canadian (DOS)",
355 863, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
356 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
357 "ibm863", "ibm863", "ibm863" },
358 { "Nordic (DOS)",
359 865, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
360 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
361 "ibm865", "ibm865", "ibm865" },
362 { "Western European (Windows)",
363 1252, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
364 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
365 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
366 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
367 "windows-1252", "windows-1252", "iso-8859-1" },
368 { "Western European (Mac)",
369 10000, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
370 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
371 "macintosh", "macintosh", "macintosh" },
372 { "Icelandic (Mac)",
373 10079, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
374 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
375 "x-mac-icelandic", "x-mac-icelandic", "x-mac-icelandic" },
376 { "US-ASCII",
377 20127, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT | MIMECONTF_EXPORT |
378 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_VALID |
379 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
380 "us-ascii", "us-ascii", "us-ascii" },
381 { "Western European (ISO)",
382 28591, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
383 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
384 MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
385 MIMECONTF_MIME_LATEST,
386 "iso-8859-1", "iso-8859-1", "iso-8859-1" },
387 { "Latin 9 (ISO)",
388 28605, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT |
389 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
390 MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
391 MIMECONTF_MIME_LATEST,
392 "iso-8859-15", "iso-8859-15", "iso-8859-15" }
393 };
394 static const MIME_CP_INFO unicode_cp[] =
395 {
396 { "Unicode",
397 CP_UNICODE, MIMECONTF_MINIMAL | MIMECONTF_IMPORT |
398 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
399 MIMECONTF_VALID | MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 |
400 MIMECONTF_MIME_LATEST,
401 "unicode", "unicode", "unicode" },
402 { "Unicode (UTF-7)",
403 CP_UTF7, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT |
404 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_EXPORT | MIMECONTF_VALID |
405 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
406 "utf-7", "utf-7", "utf-7" },
407 { "Unicode (UTF-8)",
408 CP_UTF8, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
409 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
410 MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
411 MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
412 "utf-8", "utf-8", "utf-8" }
413 };
414
415 static const struct mlang_data
416 {
417 const char *description;
418 UINT family_codepage;
419 UINT number_of_cp;
420 const MIME_CP_INFO *mime_cp_info;
421 const char *fixed_font;
422 const char *proportional_font;
423 } mlang_data[] =
424 {
425 { "Arabic",1256,sizeof(arabic_cp)/sizeof(arabic_cp[0]),arabic_cp,
426 "Courier","Arial" }, /* FIXME */
427 { "Baltic",1257,sizeof(baltic_cp)/sizeof(baltic_cp[0]),baltic_cp,
428 "Courier","Arial" }, /* FIXME */
429 { "Chinese Simplified",936,sizeof(chinese_simplified_cp)/sizeof(chinese_simplified_cp[0]),chinese_simplified_cp,
430 "Courier","Arial" }, /* FIXME */
431 { "Chinese Traditional",950,sizeof(chinese_traditional_cp)/sizeof(chinese_traditional_cp[0]),chinese_traditional_cp,
432 "Courier","Arial" }, /* FIXME */
433 { "Central European",1250,sizeof(central_european_cp)/sizeof(central_european_cp[0]),central_european_cp,
434 "Courier","Arial" }, /* FIXME */
435 { "Cyrillic",1251,sizeof(cyrillic_cp)/sizeof(cyrillic_cp[0]),cyrillic_cp,
436 "Courier","Arial" }, /* FIXME */
437 { "Greek",1253,sizeof(greek_cp)/sizeof(greek_cp[0]),greek_cp,
438 "Courier","Arial" }, /* FIXME */
439 { "Hebrew",1255,sizeof(hebrew_cp)/sizeof(hebrew_cp[0]),hebrew_cp,
440 "Courier","Arial" }, /* FIXME */
441 { "Japanese",932,sizeof(japanese_cp)/sizeof(japanese_cp[0]),japanese_cp,
442 "Courier","Arial" }, /* FIXME */
443 { "Korean",949,sizeof(korean_cp)/sizeof(korean_cp[0]),korean_cp,
444 "Courier","Arial" }, /* FIXME */
445 { "Thai",874,sizeof(thai_cp)/sizeof(thai_cp[0]),thai_cp,
446 "Courier","Arial" }, /* FIXME */
447 { "Turkish",1254,sizeof(turkish_cp)/sizeof(turkish_cp[0]),turkish_cp,
448 "Courier","Arial" }, /* FIXME */
449 { "Vietnamese",1258,sizeof(vietnamese_cp)/sizeof(vietnamese_cp[0]),vietnamese_cp,
450 "Courier","Arial" }, /* FIXME */
451 { "Western European",1252,sizeof(western_cp)/sizeof(western_cp[0]),western_cp,
452 "Courier","Arial" }, /* FIXME */
453 { "Unicode",CP_UNICODE,sizeof(unicode_cp)/sizeof(unicode_cp[0]),unicode_cp,
454 "Courier","Arial" } /* FIXME */
455 };
456
457 static void fill_cp_info(const struct mlang_data *ml_data, UINT index, MIMECPINFO *mime_cp_info);
458
459 static LONG dll_count;
460
461 /*
462 * Dll lifetime tracking declaration
463 */
464 static void LockModule(void)
465 {
466 InterlockedIncrement(&dll_count);
467 }
468
469 static void UnlockModule(void)
470 {
471 InterlockedDecrement(&dll_count);
472 }
473
474 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
475 {
476 switch(fdwReason) {
477 case DLL_PROCESS_ATTACH:
478 MLANG_tls_index = TlsAlloc();
479 DisableThreadLibraryCalls(hInstDLL);
480 break;
481 case DLL_PROCESS_DETACH:
482 TlsFree(MLANG_tls_index);
483 break;
484 }
485 return TRUE;
486 }
487
488 HRESULT WINAPI ConvertINetMultiByteToUnicode(
489 LPDWORD pdwMode,
490 DWORD dwEncoding,
491 LPCSTR pSrcStr,
492 LPINT pcSrcSize,
493 LPWSTR pDstStr,
494 LPINT pcDstSize)
495 {
496 INT src_len = -1;
497
498 TRACE("%p %d %s %p %p %p\n", pdwMode, dwEncoding,
499 debugstr_a(pSrcStr), pcSrcSize, pDstStr, pcDstSize);
500
501 if (!pcDstSize)
502 return E_FAIL;
503
504 if (!pcSrcSize)
505 pcSrcSize = &src_len;
506
507 if (!*pcSrcSize)
508 {
509 *pcDstSize = 0;
510 return S_OK;
511 }
512
513 switch (dwEncoding)
514 {
515 case CP_UNICODE:
516 if (*pcSrcSize == -1)
517 *pcSrcSize = lstrlenW((LPCWSTR)pSrcStr);
518 *pcDstSize = min(*pcSrcSize, *pcDstSize);
519 *pcSrcSize *= sizeof(WCHAR);
520 if (pDstStr)
521 memmove(pDstStr, pSrcStr, *pcDstSize * sizeof(WCHAR));
522 break;
523
524 default:
525 if (*pcSrcSize == -1)
526 *pcSrcSize = lstrlenA(pSrcStr);
527
528 if (pDstStr)
529 *pcDstSize = MultiByteToWideChar(dwEncoding, 0, pSrcStr, *pcSrcSize, pDstStr, *pcDstSize);
530 else
531 *pcDstSize = MultiByteToWideChar(dwEncoding, 0, pSrcStr, *pcSrcSize, NULL, 0);
532 break;
533 }
534
535 if (!*pcDstSize)
536 return E_FAIL;
537
538 return S_OK;
539 }
540
541 HRESULT WINAPI ConvertINetUnicodeToMultiByte(
542 LPDWORD pdwMode,
543 DWORD dwEncoding,
544 LPCWSTR pSrcStr,
545 LPINT pcSrcSize,
546 LPSTR pDstStr,
547 LPINT pcDstSize)
548 {
549
550 INT src_len = -1;
551
552 TRACE("%p %d %s %p %p %p\n", pdwMode, dwEncoding,
553 debugstr_w(pSrcStr), pcSrcSize, pDstStr, pcDstSize);
554
555 if (!pcDstSize)
556 return E_FAIL;
557
558 if (!pcSrcSize)
559 pcSrcSize = &src_len;
560
561 if (!*pcSrcSize)
562 {
563 *pcDstSize = 0;
564 return S_OK;
565 }
566
567 switch (dwEncoding)
568 {
569 case CP_UNICODE:
570 if (*pcSrcSize == -1)
571 *pcSrcSize = lstrlenW(pSrcStr);
572 *pcDstSize = min(*pcSrcSize * sizeof(WCHAR), *pcDstSize);
573 if (pDstStr)
574 memmove(pDstStr, pSrcStr, *pcDstSize);
575 break;
576
577 default:
578 if (*pcSrcSize == -1)
579 *pcSrcSize = lstrlenW(pSrcStr);
580
581 if (pDstStr)
582 *pcDstSize = WideCharToMultiByte(dwEncoding, 0, pSrcStr, *pcSrcSize, pDstStr, *pcDstSize, NULL, NULL);
583 else
584 *pcDstSize = WideCharToMultiByte(dwEncoding, 0, pSrcStr, *pcSrcSize, NULL, 0, NULL, NULL);
585 break;
586 }
587
588
589 if (!*pcDstSize)
590 return E_FAIL;
591
592 return S_OK;
593 }
594
595 HRESULT WINAPI ConvertINetString(
596 LPDWORD pdwMode,
597 DWORD dwSrcEncoding,
598 DWORD dwDstEncoding,
599 LPCSTR pSrcStr,
600 LPINT pcSrcSize,
601 LPSTR pDstStr,
602 LPINT pcDstSize
603 )
604 {
605 TRACE("%p %d %d %s %p %p %p\n", pdwMode, dwSrcEncoding, dwDstEncoding,
606 debugstr_a(pSrcStr), pcSrcSize, pDstStr, pcDstSize);
607
608 if (dwSrcEncoding == CP_UNICODE)
609 {
610 INT cSrcSizeW;
611 if (pcSrcSize && *pcSrcSize != -1)
612 {
613 cSrcSizeW = *pcSrcSize / sizeof(WCHAR);
614 pcSrcSize = &cSrcSizeW;
615 }
616 return ConvertINetUnicodeToMultiByte(pdwMode, dwDstEncoding, (LPCWSTR)pSrcStr, pcSrcSize, pDstStr, pcDstSize);
617 }
618 else if (dwDstEncoding == CP_UNICODE)
619 {
620 HRESULT hr = ConvertINetMultiByteToUnicode(pdwMode, dwSrcEncoding, pSrcStr, pcSrcSize, (LPWSTR)pDstStr, pcDstSize);
621 *pcDstSize *= sizeof(WCHAR);
622 return hr;
623 }
624 else
625 {
626 INT cDstSizeW;
627 LPWSTR pDstStrW;
628 HRESULT hr;
629
630 TRACE("convert %s from %d to %d\n", debugstr_a(pSrcStr), dwSrcEncoding, dwDstEncoding);
631
632 hr = ConvertINetMultiByteToUnicode(pdwMode, dwSrcEncoding, pSrcStr, pcSrcSize, NULL, &cDstSizeW);
633 if (hr != S_OK)
634 return hr;
635
636 pDstStrW = HeapAlloc(GetProcessHeap(), 0, cDstSizeW * sizeof(WCHAR));
637 hr = ConvertINetMultiByteToUnicode(pdwMode, dwSrcEncoding, pSrcStr, pcSrcSize, pDstStrW, &cDstSizeW);
638 if (hr == S_OK)
639 hr = ConvertINetUnicodeToMultiByte(pdwMode, dwDstEncoding, pDstStrW, &cDstSizeW, pDstStr, pcDstSize);
640
641 HeapFree(GetProcessHeap(), 0, pDstStrW);
642 return hr;
643 }
644 }
645
646 static HRESULT GetFamilyCodePage(
647 UINT uiCodePage,
648 UINT* puiFamilyCodePage)
649 {
650 UINT i, n;
651
652 TRACE("%u %p\n", uiCodePage, puiFamilyCodePage);
653
654 if (!puiFamilyCodePage) return S_FALSE;
655
656 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
657 {
658 for (n = 0; n < mlang_data[i].number_of_cp; n++)
659 {
660 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
661 {
662 *puiFamilyCodePage = mlang_data[i].family_codepage;
663 return S_OK;
664 }
665 }
666 }
667
668 return S_FALSE;
669 }
670
671 HRESULT WINAPI IsConvertINetStringAvailable(
672 DWORD dwSrcEncoding,
673 DWORD dwDstEncoding)
674 {
675 UINT src_family, dst_family;
676
677 TRACE("%d %d\n", dwSrcEncoding, dwDstEncoding);
678
679 if (GetFamilyCodePage(dwSrcEncoding, &src_family) != S_OK ||
680 GetFamilyCodePage(dwDstEncoding, &dst_family) != S_OK)
681 return S_FALSE;
682
683 if (src_family == dst_family) return S_OK;
684
685 /* we can convert any codepage to/from unicode */
686 if (src_family == CP_UNICODE || dst_family == CP_UNICODE) return S_OK;
687
688 return S_FALSE;
689 }
690
691 static inline INT lcid_to_rfc1766A( LCID lcid, LPSTR rfc1766, INT len )
692 {
693 INT n = GetLocaleInfoA( lcid, LOCALE_SISO639LANGNAME, rfc1766, len );
694 if (n)
695 {
696 rfc1766[n - 1] = '-';
697 n += GetLocaleInfoA( lcid, LOCALE_SISO3166CTRYNAME, rfc1766 + n, len - n );
698 LCMapStringA( LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, rfc1766, n, rfc1766, len );
699 return n;
700 }
701 return 0;
702 }
703
704 static inline INT lcid_to_rfc1766W( LCID lcid, LPWSTR rfc1766, INT len )
705 {
706 INT n = GetLocaleInfoW( lcid, LOCALE_SISO639LANGNAME, rfc1766, len );
707 INT save = n;
708 if (n)
709 {
710 rfc1766[n - 1] = '-';
711 n += GetLocaleInfoW( lcid, LOCALE_SISO3166CTRYNAME, rfc1766 + n, len - n );
712 if (n == save)
713 rfc1766[n - 1] = '\0';
714 LCMapStringW( LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, rfc1766, n, rfc1766, len );
715 return n;
716 }
717 return 0;
718 }
719
720 HRESULT WINAPI LcidToRfc1766A(
721 LCID lcid,
722 LPSTR pszRfc1766,
723 INT nChar)
724 {
725 TRACE("%04x %p %u\n", lcid, pszRfc1766, nChar);
726
727 if (lcid_to_rfc1766A( lcid, pszRfc1766, nChar ))
728 return S_OK;
729
730 return S_FALSE;
731 }
732
733 HRESULT WINAPI LcidToRfc1766W(
734 LCID lcid,
735 LPWSTR pszRfc1766,
736 INT nChar)
737 {
738 TRACE("%04x %p %u\n", lcid, pszRfc1766, nChar);
739
740 if (lcid_to_rfc1766W( lcid, pszRfc1766, nChar ))
741 return S_OK;
742
743 return S_FALSE;
744 }
745
746 static HRESULT lcid_from_rfc1766(IEnumRfc1766 *iface, LCID *lcid, LPCWSTR rfc1766)
747 {
748 RFC1766INFO info;
749 ULONG num;
750
751 while (IEnumRfc1766_Next(iface, 1, &info, &num) == S_OK)
752 {
753 if (!strcmpW(info.wszRfc1766, rfc1766))
754 {
755 *lcid = info.lcid;
756 return S_OK;
757 }
758 if (strlenW(rfc1766) == 2 && !memcmp(info.wszRfc1766, rfc1766, 2 * sizeof(WCHAR)))
759 {
760 *lcid = PRIMARYLANGID(info.lcid);
761 return S_OK;
762 }
763 }
764
765 return E_FAIL;
766 }
767
768 HRESULT WINAPI Rfc1766ToLcidW(LCID *pLocale, LPCWSTR pszRfc1766)
769 {
770 IEnumRfc1766 *enumrfc1766;
771 HRESULT hr;
772
773 TRACE("(%p, %s)\n", pLocale, debugstr_w(pszRfc1766));
774
775 if (!pLocale || !pszRfc1766)
776 return E_INVALIDARG;
777
778 *pLocale = 0;
779
780 hr = EnumRfc1766_create(0, &enumrfc1766);
781 if (FAILED(hr))
782 return hr;
783
784 hr = lcid_from_rfc1766(enumrfc1766, pLocale, pszRfc1766);
785 IEnumRfc1766_Release(enumrfc1766);
786
787 return hr;
788 }
789
790 HRESULT WINAPI Rfc1766ToLcidA(LCID *lcid, LPCSTR rfc1766A)
791 {
792 WCHAR rfc1766W[MAX_RFC1766_NAME + 1];
793
794 MultiByteToWideChar(CP_ACP, 0, rfc1766A, -1, rfc1766W, MAX_RFC1766_NAME);
795 rfc1766W[MAX_RFC1766_NAME] = 0;
796
797 return Rfc1766ToLcidW(lcid, rfc1766W);
798 }
799
800 /******************************************************************************
801 * MLANG ClassFactory
802 */
803 typedef struct {
804 IClassFactory ITF_IClassFactory;
805
806 LONG ref;
807 HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
808 } IClassFactoryImpl;
809
810 struct object_creation_info
811 {
812 const CLSID *clsid;
813 LPCSTR szClassName;
814 HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
815 };
816
817 static const struct object_creation_info object_creation[] =
818 {
819 { &CLSID_CMultiLanguage, "CLSID_CMultiLanguage", MultiLanguage_create },
820 };
821
822 static HRESULT WINAPI
823 MLANGCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
824 {
825 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
826
827 TRACE("%s\n", debugstr_guid(riid) );
828
829 if (IsEqualGUID(riid, &IID_IUnknown)
830 || IsEqualGUID(riid, &IID_IClassFactory))
831 {
832 IClassFactory_AddRef(iface);
833 *ppobj = This;
834 return S_OK;
835 }
836
837 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
838 return E_NOINTERFACE;
839 }
840
841 static ULONG WINAPI MLANGCF_AddRef(LPCLASSFACTORY iface)
842 {
843 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
844 return InterlockedIncrement(&This->ref);
845 }
846
847 static ULONG WINAPI MLANGCF_Release(LPCLASSFACTORY iface)
848 {
849 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
850
851 ULONG ref = InterlockedDecrement(&This->ref);
852
853 if (ref == 0)
854 {
855 TRACE("Destroying %p\n", This);
856 HeapFree(GetProcessHeap(), 0, This);
857 }
858
859 return ref;
860 }
861
862 static HRESULT WINAPI MLANGCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter,
863 REFIID riid, LPVOID *ppobj)
864 {
865 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
866 HRESULT hres;
867 LPUNKNOWN punk;
868
869 TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
870
871 *ppobj = NULL;
872 hres = This->pfnCreateInstance(pOuter, (LPVOID *) &punk);
873 if (SUCCEEDED(hres)) {
874 hres = IUnknown_QueryInterface(punk, riid, ppobj);
875 IUnknown_Release(punk);
876 }
877 TRACE("returning (%p) -> %x\n", *ppobj, hres);
878 return hres;
879 }
880
881 static HRESULT WINAPI MLANGCF_LockServer(LPCLASSFACTORY iface,BOOL dolock)
882 {
883 if (dolock)
884 LockModule();
885 else
886 UnlockModule();
887
888 return S_OK;
889 }
890
891 static const IClassFactoryVtbl MLANGCF_Vtbl =
892 {
893 MLANGCF_QueryInterface,
894 MLANGCF_AddRef,
895 MLANGCF_Release,
896 MLANGCF_CreateInstance,
897 MLANGCF_LockServer
898 };
899
900 /******************************************************************
901 * DllGetClassObject (MLANG.@)
902 */
903 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
904 {
905 int i;
906 IClassFactoryImpl *factory;
907
908 TRACE("%s %s %p\n",debugstr_guid(rclsid), debugstr_guid(iid), ppv);
909
910 if ( !IsEqualGUID( &IID_IClassFactory, iid )
911 && ! IsEqualGUID( &IID_IUnknown, iid) )
912 return E_NOINTERFACE;
913
914 for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
915 {
916 if (IsEqualGUID(object_creation[i].clsid, rclsid))
917 break;
918 }
919
920 if (i == sizeof(object_creation)/sizeof(object_creation[0]))
921 {
922 FIXME("%s: no class found.\n", debugstr_guid(rclsid));
923 return CLASS_E_CLASSNOTAVAILABLE;
924 }
925
926 TRACE("Creating a class factory for %s\n",object_creation[i].szClassName);
927
928 factory = HeapAlloc(GetProcessHeap(), 0, sizeof(*factory));
929 if (factory == NULL) return E_OUTOFMEMORY;
930
931 factory->ITF_IClassFactory.lpVtbl = &MLANGCF_Vtbl;
932 factory->ref = 1;
933
934 factory->pfnCreateInstance = object_creation[i].pfnCreateInstance;
935
936 *ppv = &(factory->ITF_IClassFactory);
937
938 TRACE("(%p) <- %p\n", ppv, &(factory->ITF_IClassFactory) );
939
940 return S_OK;
941 }
942
943
944 /******************************************************************************/
945
946 typedef struct tagMLang_impl
947 {
948 const IMLangFontLinkVtbl *vtbl_IMLangFontLink;
949 const IMultiLanguageVtbl *vtbl_IMultiLanguage;
950 const IMultiLanguage3Vtbl *vtbl_IMultiLanguage3;
951 LONG ref;
952 DWORD total_cp, total_scripts;
953 } MLang_impl;
954
955 static ULONG WINAPI MLang_AddRef( MLang_impl* This)
956 {
957 return InterlockedIncrement(&This->ref);
958 }
959
960 static ULONG WINAPI MLang_Release( MLang_impl* This )
961 {
962 ULONG ref = InterlockedDecrement(&This->ref);
963
964 TRACE("%p ref = %d\n", This, ref);
965 if (ref == 0)
966 {
967 TRACE("Destroying %p\n", This);
968 HeapFree(GetProcessHeap(), 0, This);
969 UnlockModule();
970 }
971
972 return ref;
973 }
974
975 static HRESULT WINAPI MLang_QueryInterface(
976 MLang_impl* This,
977 REFIID riid,
978 void** ppvObject)
979 {
980 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
981
982 if (IsEqualGUID(riid, &IID_IUnknown)
983 || IsEqualGUID(riid, &IID_IMLangCodePages)
984 || IsEqualGUID(riid, &IID_IMLangFontLink))
985 {
986 MLang_AddRef(This);
987 TRACE("Returning IID_IMLangFontLink %p ref = %d\n", This, This->ref);
988 *ppvObject = &(This->vtbl_IMLangFontLink);
989 return S_OK;
990 }
991
992 if (IsEqualGUID(riid, &IID_IMultiLanguage) )
993 {
994 MLang_AddRef(This);
995 TRACE("Returning IID_IMultiLanguage %p ref = %d\n", This, This->ref);
996 *ppvObject = &(This->vtbl_IMultiLanguage);
997 return S_OK;
998 }
999
1000 if (IsEqualGUID(riid, &IID_IMultiLanguage2) )
1001 {
1002 MLang_AddRef(This);
1003 *ppvObject = &(This->vtbl_IMultiLanguage3);
1004 TRACE("Returning IID_IMultiLanguage2 %p ref = %d\n", This, This->ref);
1005 return S_OK;
1006 }
1007
1008 if (IsEqualGUID(riid, &IID_IMultiLanguage3) )
1009 {
1010 MLang_AddRef(This);
1011 *ppvObject = &(This->vtbl_IMultiLanguage3);
1012 TRACE("Returning IID_IMultiLanguage3 %p ref = %d\n", This, This->ref);
1013 return S_OK;
1014 }
1015
1016 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1017 return E_NOINTERFACE;
1018 }
1019
1020 /******************************************************************************/
1021
1022 typedef struct tagEnumCodePage_impl
1023 {
1024 const IEnumCodePageVtbl *vtbl_IEnumCodePage;
1025 LONG ref;
1026 MIMECPINFO *cpinfo;
1027 DWORD total, pos;
1028 } EnumCodePage_impl;
1029
1030 static HRESULT WINAPI fnIEnumCodePage_QueryInterface(
1031 IEnumCodePage* iface,
1032 REFIID riid,
1033 void** ppvObject)
1034 {
1035 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1036
1037 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1038
1039 if (IsEqualGUID(riid, &IID_IUnknown)
1040 || IsEqualGUID(riid, &IID_IEnumCodePage))
1041 {
1042 IEnumCodePage_AddRef(iface);
1043 TRACE("Returning IID_IEnumCodePage %p ref = %d\n", This, This->ref);
1044 *ppvObject = &(This->vtbl_IEnumCodePage);
1045 return S_OK;
1046 }
1047
1048 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1049 return E_NOINTERFACE;
1050 }
1051
1052 static ULONG WINAPI fnIEnumCodePage_AddRef(
1053 IEnumCodePage* iface)
1054 {
1055 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1056 return InterlockedIncrement(&This->ref);
1057 }
1058
1059 static ULONG WINAPI fnIEnumCodePage_Release(
1060 IEnumCodePage* iface)
1061 {
1062 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1063 ULONG ref = InterlockedDecrement(&This->ref);
1064
1065 TRACE("%p ref = %d\n", This, ref);
1066 if (ref == 0)
1067 {
1068 TRACE("Destroying %p\n", This);
1069 HeapFree(GetProcessHeap(), 0, This->cpinfo);
1070 HeapFree(GetProcessHeap(), 0, This);
1071 }
1072
1073 return ref;
1074 }
1075
1076 static HRESULT WINAPI fnIEnumCodePage_Clone(
1077 IEnumCodePage* iface,
1078 IEnumCodePage** ppEnum)
1079 {
1080 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1081 FIXME("%p %p\n", This, ppEnum);
1082 return E_NOTIMPL;
1083 }
1084
1085 static HRESULT WINAPI fnIEnumCodePage_Next(
1086 IEnumCodePage* iface,
1087 ULONG celt,
1088 PMIMECPINFO rgelt,
1089 ULONG* pceltFetched)
1090 {
1091 ULONG i;
1092
1093 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1094 TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
1095
1096 if (!pceltFetched) return S_FALSE;
1097 *pceltFetched = 0;
1098
1099 if (!rgelt) return S_FALSE;
1100
1101 if (This->pos + celt > This->total)
1102 celt = This->total - This->pos;
1103
1104 if (!celt) return S_FALSE;
1105
1106 memcpy(rgelt, This->cpinfo + This->pos, celt * sizeof(MIMECPINFO));
1107 *pceltFetched = celt;
1108 This->pos += celt;
1109
1110 for (i = 0; i < celt; i++)
1111 {
1112 TRACE("#%u: %08x %u %u %s %s %s %s %s %s %d\n",
1113 i, rgelt[i].dwFlags, rgelt[i].uiCodePage,
1114 rgelt[i].uiFamilyCodePage,
1115 wine_dbgstr_w(rgelt[i].wszDescription),
1116 wine_dbgstr_w(rgelt[i].wszWebCharset),
1117 wine_dbgstr_w(rgelt[i].wszHeaderCharset),
1118 wine_dbgstr_w(rgelt[i].wszBodyCharset),
1119 wine_dbgstr_w(rgelt[i].wszFixedWidthFont),
1120 wine_dbgstr_w(rgelt[i].wszProportionalFont),
1121 rgelt[i].bGDICharset);
1122 }
1123 return S_OK;
1124 }
1125
1126 static HRESULT WINAPI fnIEnumCodePage_Reset(
1127 IEnumCodePage* iface)
1128 {
1129 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1130 TRACE("%p\n", This);
1131
1132 This->pos = 0;
1133 return S_OK;
1134 }
1135
1136 static HRESULT WINAPI fnIEnumCodePage_Skip(
1137 IEnumCodePage* iface,
1138 ULONG celt)
1139 {
1140 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1141 TRACE("%p %u\n", This, celt);
1142
1143 if (celt >= This->total) return S_FALSE;
1144
1145 This->pos += celt;
1146 return S_OK;
1147 }
1148
1149 static const IEnumCodePageVtbl IEnumCodePage_vtbl =
1150 {
1151 fnIEnumCodePage_QueryInterface,
1152 fnIEnumCodePage_AddRef,
1153 fnIEnumCodePage_Release,
1154 fnIEnumCodePage_Clone,
1155 fnIEnumCodePage_Next,
1156 fnIEnumCodePage_Reset,
1157 fnIEnumCodePage_Skip
1158 };
1159
1160 static HRESULT EnumCodePage_create( MLang_impl* mlang, DWORD grfFlags,
1161 LANGID LangId, IEnumCodePage** ppEnumCodePage )
1162 {
1163 EnumCodePage_impl *ecp;
1164 MIMECPINFO *cpinfo;
1165 UINT i, n;
1166
1167 TRACE("%p, %08x, %04x, %p\n", mlang, grfFlags, LangId, ppEnumCodePage);
1168
1169 if (!grfFlags) /* enumerate internal data base of encodings */
1170 grfFlags = MIMECONTF_MIME_LATEST;
1171
1172 ecp = HeapAlloc( GetProcessHeap(), 0, sizeof (EnumCodePage_impl) );
1173 ecp->vtbl_IEnumCodePage = &IEnumCodePage_vtbl;
1174 ecp->ref = 1;
1175 ecp->pos = 0;
1176 ecp->total = 0;
1177 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1178 {
1179 for (n = 0; n < mlang_data[i].number_of_cp; n++)
1180 {
1181 if (mlang_data[i].mime_cp_info[n].flags & grfFlags)
1182 ecp->total++;
1183 }
1184 }
1185
1186 ecp->cpinfo = HeapAlloc(GetProcessHeap(), 0,
1187 sizeof(MIMECPINFO) * ecp->total);
1188 cpinfo = ecp->cpinfo;
1189
1190 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1191 {
1192 for (n = 0; n < mlang_data[i].number_of_cp; n++)
1193 {
1194 if (mlang_data[i].mime_cp_info[n].flags & grfFlags)
1195 fill_cp_info(&mlang_data[i], n, cpinfo++);
1196 }
1197 }
1198
1199 TRACE("enumerated %d codepages with flags %08x\n", ecp->total, grfFlags);
1200
1201 *ppEnumCodePage = (IEnumCodePage*) ecp;
1202
1203 return S_OK;
1204 }
1205
1206 /******************************************************************************/
1207
1208 typedef struct tagEnumScript_impl
1209 {
1210 const IEnumScriptVtbl *vtbl_IEnumScript;
1211 LONG ref;
1212 SCRIPTINFO *script_info;
1213 DWORD total, pos;
1214 } EnumScript_impl;
1215
1216 static HRESULT WINAPI fnIEnumScript_QueryInterface(
1217 IEnumScript* iface,
1218 REFIID riid,
1219 void** ppvObject)
1220 {
1221 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1222
1223 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1224
1225 if (IsEqualGUID(riid, &IID_IUnknown)
1226 || IsEqualGUID(riid, &IID_IEnumScript))
1227 {
1228 IEnumScript_AddRef(iface);
1229 TRACE("Returning IID_IEnumScript %p ref = %d\n", This, This->ref);
1230 *ppvObject = &(This->vtbl_IEnumScript);
1231 return S_OK;
1232 }
1233
1234 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1235 return E_NOINTERFACE;
1236 }
1237
1238 static ULONG WINAPI fnIEnumScript_AddRef(
1239 IEnumScript* iface)
1240 {
1241 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1242 return InterlockedIncrement(&This->ref);
1243 }
1244
1245 static ULONG WINAPI fnIEnumScript_Release(
1246 IEnumScript* iface)
1247 {
1248 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1249 ULONG ref = InterlockedDecrement(&This->ref);
1250
1251 TRACE("%p ref = %d\n", This, ref);
1252 if (ref == 0)
1253 {
1254 TRACE("Destroying %p\n", This);
1255 HeapFree(GetProcessHeap(), 0, This->script_info);
1256 HeapFree(GetProcessHeap(), 0, This);
1257 }
1258
1259 return ref;
1260 }
1261
1262 static HRESULT WINAPI fnIEnumScript_Clone(
1263 IEnumScript* iface,
1264 IEnumScript** ppEnum)
1265 {
1266 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1267 FIXME("%p %p: stub!\n", This, ppEnum);
1268 return E_NOTIMPL;
1269 }
1270
1271 static HRESULT WINAPI fnIEnumScript_Next(
1272 IEnumScript* iface,
1273 ULONG celt,
1274 PSCRIPTINFO rgelt,
1275 ULONG* pceltFetched)
1276 {
1277 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1278 TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
1279
1280 if (!pceltFetched || !rgelt) return E_FAIL;
1281
1282 *pceltFetched = 0;
1283
1284 if (This->pos + celt > This->total)
1285 celt = This->total - This->pos;
1286
1287 if (!celt) return S_FALSE;
1288
1289 memcpy(rgelt, This->script_info + This->pos, celt * sizeof(SCRIPTINFO));
1290 *pceltFetched = celt;
1291 This->pos += celt;
1292
1293 return S_OK;
1294 }
1295
1296 static HRESULT WINAPI fnIEnumScript_Reset(
1297 IEnumScript* iface)
1298 {
1299 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1300 TRACE("%p\n", This);
1301
1302 This->pos = 0;
1303 return S_OK;
1304 }
1305
1306 static HRESULT WINAPI fnIEnumScript_Skip(
1307 IEnumScript* iface,
1308 ULONG celt)
1309 {
1310 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1311 TRACE("%p %u\n", This, celt);
1312
1313 if (celt >= This->total) return S_FALSE;
1314
1315 This->pos += celt;
1316 return S_OK;
1317 }
1318
1319 static const IEnumScriptVtbl IEnumScript_vtbl =
1320 {
1321 fnIEnumScript_QueryInterface,
1322 fnIEnumScript_AddRef,
1323 fnIEnumScript_Release,
1324 fnIEnumScript_Clone,
1325 fnIEnumScript_Next,
1326 fnIEnumScript_Reset,
1327 fnIEnumScript_Skip
1328 };
1329
1330 static HRESULT EnumScript_create( MLang_impl* mlang, DWORD dwFlags,
1331 LANGID LangId, IEnumScript** ppEnumScript )
1332 {
1333 EnumScript_impl *es;
1334 UINT i;
1335
1336 TRACE("%p, %08x, %04x, %p: stub!\n", mlang, dwFlags, LangId, ppEnumScript);
1337
1338 if (!dwFlags) /* enumerate all available scripts */
1339 dwFlags = SCRIPTCONTF_SCRIPT_USER | SCRIPTCONTF_SCRIPT_HIDE | SCRIPTCONTF_SCRIPT_SYSTEM;
1340
1341 es = HeapAlloc( GetProcessHeap(), 0, sizeof (EnumScript_impl) );
1342 es->vtbl_IEnumScript = &IEnumScript_vtbl;
1343 es->ref = 1;
1344 es->pos = 0;
1345 /* do not enumerate unicode flavours */
1346 es->total = sizeof(mlang_data)/sizeof(mlang_data[0]) - 1;
1347 es->script_info = HeapAlloc(GetProcessHeap(), 0, sizeof(SCRIPTINFO) * es->total);
1348
1349 for (i = 0; i < es->total; i++)
1350 {
1351 es->script_info[i].ScriptId = i;
1352 es->script_info[i].uiCodePage = mlang_data[i].family_codepage;
1353 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].description, -1,
1354 es->script_info[i].wszDescription, MAX_SCRIPT_NAME);
1355 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].fixed_font, -1,
1356 es->script_info[i].wszFixedWidthFont, MAX_MIMEFACE_NAME);
1357 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].proportional_font, -1,
1358 es->script_info[i].wszProportionalFont, MAX_MIMEFACE_NAME);
1359 }
1360
1361 TRACE("enumerated %d scripts with flags %08x\n", es->total, dwFlags);
1362
1363 *ppEnumScript = (IEnumScript *)es;
1364
1365 return S_OK;
1366 }
1367
1368 /******************************************************************************/
1369
1370 static HRESULT WINAPI fnIMLangFontLink_QueryInterface(
1371 IMLangFontLink* iface,
1372 REFIID riid,
1373 void** ppvObject)
1374 {
1375 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1376 return MLang_QueryInterface( This, riid, ppvObject );
1377 }
1378
1379 static ULONG WINAPI fnIMLangFontLink_AddRef(
1380 IMLangFontLink* iface)
1381 {
1382 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1383 return MLang_AddRef( This );
1384 }
1385
1386 static ULONG WINAPI fnIMLangFontLink_Release(
1387 IMLangFontLink* iface)
1388 {
1389 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1390 return MLang_Release( This );
1391 }
1392
1393 static HRESULT WINAPI fnIMLangFontLink_GetCharCodePages(
1394 IMLangFontLink* iface,
1395 WCHAR chSrc,
1396 DWORD* pdwCodePages)
1397 {
1398 FIXME("\n");
1399 return E_NOTIMPL;
1400 }
1401
1402 static HRESULT WINAPI fnIMLangFontLink_GetStrCodePages(
1403 IMLangFontLink* iface,
1404 const WCHAR* pszSrc,
1405 long cchSrc,
1406 DWORD dwPriorityCodePages,
1407 DWORD* pdwCodePages,
1408 long* pcchCodePages)
1409 {
1410 FIXME("(pszSrc=%s, cchSrc=%ld, dwPriorityCodePages=%d) stub\n", debugstr_w(pszSrc), cchSrc, dwPriorityCodePages);
1411 *pdwCodePages = 0;
1412 *pcchCodePages = 1;
1413 return S_OK;
1414 }
1415
1416 static HRESULT WINAPI fnIMLangFontLink_CodePageToCodePages(
1417 IMLangFontLink* iface,
1418 UINT uCodePage,
1419 DWORD* pdwCodePages)
1420 {
1421 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1422 CHARSETINFO cs;
1423 BOOL rc;
1424
1425 TRACE("(%p) Seeking %u\n",This, uCodePage);
1426 memset(&cs, 0, sizeof(cs));
1427
1428 rc = TranslateCharsetInfo((DWORD*)uCodePage, &cs, TCI_SRCCODEPAGE);
1429
1430 if (rc)
1431 {
1432 *pdwCodePages = cs.fs.fsCsb[0];
1433 TRACE("resulting CodePages 0x%x\n",*pdwCodePages);
1434 }
1435 else
1436 TRACE("CodePage Not Found\n");
1437
1438 return S_OK;
1439 }
1440
1441 static HRESULT WINAPI fnIMLangFontLink_CodePagesToCodePage(
1442 IMLangFontLink* iface,
1443 DWORD dwCodePages,
1444 UINT uDefaultCodePage,
1445 UINT* puCodePage)
1446 {
1447 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1448 DWORD mask = 0x00000000;
1449 UINT i;
1450 CHARSETINFO cs;
1451 BOOL rc;
1452
1453 TRACE("(%p) scanning 0x%x default page %u\n",This, dwCodePages,
1454 uDefaultCodePage);
1455
1456 *puCodePage = 0x00000000;
1457
1458 rc = TranslateCharsetInfo((DWORD*)uDefaultCodePage, &cs, TCI_SRCCODEPAGE);
1459
1460 if (rc && (dwCodePages & cs.fs.fsCsb[0]))
1461 {
1462 TRACE("Found Default Codepage\n");
1463 *puCodePage = uDefaultCodePage;
1464 return S_OK;
1465 }
1466
1467
1468 for (i = 0; i < 32; i++)
1469 {
1470
1471 mask = 1 << i;
1472 if (dwCodePages & mask)
1473 {
1474 DWORD Csb[2];
1475 Csb[0] = mask;
1476 Csb[1] = 0x0;
1477 rc = TranslateCharsetInfo((DWORD*)Csb, &cs, TCI_SRCFONTSIG);
1478 if (!rc)
1479 continue;
1480
1481 TRACE("Falling back to least significant found CodePage %u\n",
1482 cs.ciACP);
1483 *puCodePage = cs.ciACP;
1484 return S_OK;
1485 }
1486 }
1487
1488 TRACE("no codepage found\n");
1489 return E_FAIL;
1490 }
1491
1492 static HRESULT WINAPI fnIMLangFontLink_GetFontCodePages(
1493 IMLangFontLink* iface,
1494 HDC hDC,
1495 HFONT hFont,
1496 DWORD* pdwCodePages)
1497 {
1498 HFONT old_font;
1499 FONTSIGNATURE fontsig;
1500 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1501
1502 TRACE("(%p)\n",This);
1503
1504 old_font = SelectObject(hDC,hFont);
1505 GetTextCharsetInfo(hDC,&fontsig, 0);
1506 SelectObject(hDC,old_font);
1507
1508 *pdwCodePages = fontsig.fsCsb[0];
1509 TRACE("CodePages is 0x%x\n",fontsig.fsCsb[0]);
1510
1511 return S_OK;
1512 }
1513
1514 static HRESULT WINAPI fnIMLangFontLink_MapFont(
1515 IMLangFontLink* iface,
1516 HDC hDC,
1517 DWORD dwCodePages,
1518 HFONT hSrcFont,
1519 HFONT* phDestFont)
1520 {
1521 FIXME("\n");
1522 return E_NOTIMPL;
1523 }
1524
1525 static HRESULT WINAPI fnIMLangFontLink_ReleaseFont(
1526 IMLangFontLink* iface,
1527 HFONT hFont)
1528 {
1529 FIXME("\n");
1530 return E_NOTIMPL;
1531 }
1532
1533 static HRESULT WINAPI fnIMLangFontLink_ResetFontMapping(
1534 IMLangFontLink* iface)
1535 {
1536 FIXME("\n");
1537 return E_NOTIMPL;
1538 }
1539
1540
1541 static const IMLangFontLinkVtbl IMLangFontLink_vtbl =
1542 {
1543 fnIMLangFontLink_QueryInterface,
1544 fnIMLangFontLink_AddRef,
1545 fnIMLangFontLink_Release,
1546 fnIMLangFontLink_GetCharCodePages,
1547 fnIMLangFontLink_GetStrCodePages,
1548 fnIMLangFontLink_CodePageToCodePages,
1549 fnIMLangFontLink_CodePagesToCodePage,
1550 fnIMLangFontLink_GetFontCodePages,
1551 fnIMLangFontLink_MapFont,
1552 fnIMLangFontLink_ReleaseFont,
1553 fnIMLangFontLink_ResetFontMapping,
1554 };
1555
1556 /******************************************************************************/
1557
1558 static HRESULT WINAPI fnIMultiLanguage_QueryInterface(
1559 IMultiLanguage* iface,
1560 REFIID riid,
1561 void** ppvObject)
1562 {
1563 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1564 return MLang_QueryInterface( This, riid, ppvObject );
1565 }
1566
1567 static ULONG WINAPI fnIMultiLanguage_AddRef( IMultiLanguage* iface )
1568 {
1569 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1570 return IMLangFontLink_AddRef( ((IMLangFontLink*)This) );
1571 }
1572
1573 static ULONG WINAPI fnIMultiLanguage_Release( IMultiLanguage* iface )
1574 {
1575 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1576 return IMLangFontLink_Release( ((IMLangFontLink*)This) );
1577 }
1578
1579 static HRESULT WINAPI fnIMultiLanguage_GetNumberOfCodePageInfo(
1580 IMultiLanguage* iface,
1581 UINT* pcCodePage)
1582 {
1583 FIXME("\n");
1584 return E_NOTIMPL;
1585 }
1586
1587 static HRESULT WINAPI fnIMultiLanguage_GetCodePageInfo(
1588 IMultiLanguage* iface,
1589 UINT uiCodePage,
1590 PMIMECPINFO pCodePageInfo)
1591 {
1592 UINT i, n;
1593
1594 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1595 TRACE("%p, %u, %p\n", This, uiCodePage, pCodePageInfo);
1596
1597 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1598 {
1599 for (n = 0; n < mlang_data[i].number_of_cp; n++)
1600 {
1601 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
1602 {
1603 fill_cp_info(&mlang_data[i], n, pCodePageInfo);
1604 return S_OK;
1605 }
1606 }
1607 }
1608
1609 return S_FALSE;
1610 }
1611
1612 static HRESULT WINAPI fnIMultiLanguage_GetFamilyCodePage(
1613 IMultiLanguage* iface,
1614 UINT uiCodePage,
1615 UINT* puiFamilyCodePage)
1616 {
1617 return GetFamilyCodePage(uiCodePage, puiFamilyCodePage);
1618 }
1619
1620 static HRESULT WINAPI fnIMultiLanguage_EnumCodePages(
1621 IMultiLanguage* iface,
1622 DWORD grfFlags,
1623 IEnumCodePage** ppEnumCodePage)
1624 {
1625 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1626 TRACE("%p %08x %p\n", This, grfFlags, ppEnumCodePage);
1627
1628 return EnumCodePage_create( This, grfFlags, 0, ppEnumCodePage );
1629 }
1630
1631 static HRESULT WINAPI fnIMultiLanguage_GetCharsetInfo(
1632 IMultiLanguage* iface,
1633 BSTR Charset,
1634 PMIMECSETINFO pCharsetInfo)
1635 {
1636 FIXME("\n");
1637 return E_NOTIMPL;
1638 }
1639
1640 static HRESULT WINAPI fnIMultiLanguage_IsConvertible(
1641 IMultiLanguage* iface,
1642 DWORD dwSrcEncoding,
1643 DWORD dwDstEncoding)
1644 {
1645 return IsConvertINetStringAvailable(dwSrcEncoding, dwDstEncoding);
1646 }
1647
1648 static HRESULT WINAPI fnIMultiLanguage_ConvertString(
1649 IMultiLanguage* iface,
1650 DWORD* pdwMode,
1651 DWORD dwSrcEncoding,
1652 DWORD dwDstEncoding,
1653 BYTE* pSrcStr,
1654 UINT* pcSrcSize,
1655 BYTE* pDstStr,
1656 UINT* pcDstSize)
1657 {
1658 return ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding,
1659 (LPCSTR)pSrcStr, (LPINT)pcSrcSize, (LPSTR)pDstStr, (LPINT)pcDstSize);
1660 }
1661
1662 static HRESULT WINAPI fnIMultiLanguage_ConvertStringToUnicode(
1663 IMultiLanguage* iface,
1664 DWORD* pdwMode,
1665 DWORD dwEncoding,
1666 CHAR* pSrcStr,
1667 UINT* pcSrcSize,
1668 WCHAR* pDstStr,
1669 UINT* pcDstSize)
1670 {
1671 return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
1672 (LPCSTR)pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
1673 }
1674
1675 static HRESULT WINAPI fnIMultiLanguage_ConvertStringFromUnicode(
1676 IMultiLanguage* iface,
1677 DWORD* pdwMode,
1678 DWORD dwEncoding,
1679 WCHAR* pSrcStr,
1680 UINT* pcSrcSize,
1681 CHAR* pDstStr,
1682 UINT* pcDstSize)
1683 {
1684 return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
1685 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
1686 }
1687
1688 static HRESULT WINAPI fnIMultiLanguage_ConvertStringReset(
1689 IMultiLanguage* iface)
1690 {
1691 FIXME("\n");
1692 return E_NOTIMPL;
1693 }
1694
1695 static HRESULT WINAPI fnIMultiLanguage_GetRfc1766FromLcid(
1696 IMultiLanguage* iface,
1697 LCID lcid,
1698 BSTR* pbstrRfc1766)
1699 {
1700 WCHAR buf[MAX_RFC1766_NAME];
1701
1702 TRACE("%p %04x %p\n", iface, lcid, pbstrRfc1766);
1703
1704 if (lcid_to_rfc1766W( lcid, buf, MAX_RFC1766_NAME ))
1705 {
1706 *pbstrRfc1766 = SysAllocString( buf );
1707 return S_OK;
1708 }
1709 return E_FAIL;
1710 }
1711
1712 static HRESULT WINAPI fnIMultiLanguage_GetLcidFromRfc1766(
1713 IMultiLanguage* iface,
1714 LCID* pLocale,
1715 BSTR bstrRfc1766)
1716 {
1717 HRESULT hr;
1718 IEnumRfc1766 *rfc1766;
1719
1720 TRACE("%p %p %s\n", iface, pLocale, debugstr_w(bstrRfc1766));
1721
1722 if (!pLocale || !bstrRfc1766)
1723 return E_INVALIDARG;
1724
1725 hr = IMultiLanguage_EnumRfc1766(iface, &rfc1766);
1726 if (FAILED(hr))
1727 return hr;
1728
1729 hr = lcid_from_rfc1766(rfc1766, pLocale, bstrRfc1766);
1730
1731 IEnumRfc1766_Release(rfc1766);
1732 return hr;
1733 }
1734
1735 /******************************************************************************/
1736
1737 typedef struct tagEnumRfc1766_impl
1738 {
1739 const IEnumRfc1766Vtbl *vtbl_IEnumRfc1766;
1740 LONG ref;
1741 RFC1766INFO *info;
1742 DWORD total, pos;
1743 } EnumRfc1766_impl;
1744
1745 static HRESULT WINAPI fnIEnumRfc1766_QueryInterface(
1746 IEnumRfc1766 *iface,
1747 REFIID riid,
1748 void** ppvObject)
1749 {
1750 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1751
1752 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1753
1754 if (IsEqualGUID(riid, &IID_IUnknown)
1755 || IsEqualGUID(riid, &IID_IEnumRfc1766))
1756 {
1757 IEnumRfc1766_AddRef(iface);
1758 TRACE("Returning IID_IEnumRfc1766 %p ref = %d\n", This, This->ref);
1759 *ppvObject = &(This->vtbl_IEnumRfc1766);
1760 return S_OK;
1761 }
1762
1763 WARN("(%p) -> (%s,%p), not found\n",This,debugstr_guid(riid),ppvObject);
1764 return E_NOINTERFACE;
1765 }
1766
1767 static ULONG WINAPI fnIEnumRfc1766_AddRef(
1768 IEnumRfc1766 *iface)
1769 {
1770 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1771 return InterlockedIncrement(&This->ref);
1772 }
1773
1774 static ULONG WINAPI fnIEnumRfc1766_Release(
1775 IEnumRfc1766 *iface)
1776 {
1777 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1778 ULONG ref = InterlockedDecrement(&This->ref);
1779
1780 TRACE("%p ref = %d\n", This, ref);
1781 if (ref == 0)
1782 {
1783 TRACE("Destroying %p\n", This);
1784 HeapFree(GetProcessHeap(), 0, This->info);
1785 HeapFree(GetProcessHeap(), 0, This);
1786 }
1787 return ref;
1788 }
1789
1790 static HRESULT WINAPI fnIEnumRfc1766_Clone(
1791 IEnumRfc1766 *iface,
1792 IEnumRfc1766 **ppEnum)
1793 {
1794 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1795 FIXME("%p %p\n", This, ppEnum);
1796 return E_NOTIMPL;
1797 }
1798
1799 static HRESULT WINAPI fnIEnumRfc1766_Next(
1800 IEnumRfc1766 *iface,
1801 ULONG celt,
1802 PRFC1766INFO rgelt,
1803 ULONG *pceltFetched)
1804 {
1805 ULONG i;
1806
1807 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1808 TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
1809
1810 if (!pceltFetched) return S_FALSE;
1811 *pceltFetched = 0;
1812
1813 if (!rgelt) return S_FALSE;
1814
1815 if (This->pos + celt > This->total)
1816 celt = This->total - This->pos;
1817
1818 if (!celt) return S_FALSE;
1819
1820 memcpy(rgelt, This->info + This->pos, celt * sizeof(RFC1766INFO));
1821 *pceltFetched = celt;
1822 This->pos += celt;
1823
1824 for (i = 0; i < celt; i++)
1825 {
1826 TRACE("#%u: %08x %s %s\n",
1827 i, rgelt[i].lcid,
1828 wine_dbgstr_w(rgelt[i].wszRfc1766),
1829 wine_dbgstr_w(rgelt[i].wszLocaleName));
1830 }
1831 return S_OK;
1832 }
1833
1834 static HRESULT WINAPI fnIEnumRfc1766_Reset(
1835 IEnumRfc1766 *iface)
1836 {
1837 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1838 TRACE("%p\n", This);
1839
1840 This->pos = 0;
1841 return S_OK;
1842 }
1843
1844 static HRESULT WINAPI fnIEnumRfc1766_Skip(
1845 IEnumRfc1766 *iface,
1846 ULONG celt)
1847 {
1848 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1849 TRACE("%p %u\n", This, celt);
1850
1851 if (celt >= This->total) return S_FALSE;
1852
1853 This->pos += celt;
1854 return S_OK;
1855 }
1856
1857 static const IEnumRfc1766Vtbl IEnumRfc1766_vtbl =
1858 {
1859 fnIEnumRfc1766_QueryInterface,
1860 fnIEnumRfc1766_AddRef,
1861 fnIEnumRfc1766_Release,
1862 fnIEnumRfc1766_Clone,
1863 fnIEnumRfc1766_Next,
1864 fnIEnumRfc1766_Reset,
1865 fnIEnumRfc1766_Skip
1866 };
1867
1868 struct enum_locales_data
1869 {
1870 RFC1766INFO *info;
1871 DWORD total, allocated;
1872 };
1873
1874 static BOOL CALLBACK enum_locales_proc(LPWSTR locale)
1875 {
1876 WCHAR *end;
1877 struct enum_locales_data *data = TlsGetValue(MLANG_tls_index);
1878 RFC1766INFO *info;
1879
1880 TRACE("%s\n", debugstr_w(locale));
1881
1882 if (data->total >= data->allocated)
1883 {
1884 data->allocated += 32;
1885 data->info = HeapReAlloc(GetProcessHeap(), 0, data->info, data->allocated * sizeof(RFC1766INFO));
1886 if (!data->info) return FALSE;
1887 }
1888
1889 info = &data->info[data->total];
1890
1891 info->lcid = strtolW(locale, &end, 16);
1892 if (*end) /* invalid number */
1893 return FALSE;
1894
1895 info->wszRfc1766[0] = 0;
1896 lcid_to_rfc1766W( info->lcid, info->wszRfc1766, MAX_RFC1766_NAME );
1897
1898 info->wszLocaleName[0] = 0;
1899 GetLocaleInfoW(info->lcid, LOCALE_SLANGUAGE, info->wszLocaleName, MAX_LOCALE_NAME);
1900 TRACE("ISO639: %s SLANGUAGE: %s\n", wine_dbgstr_w(info->wszRfc1766), wine_dbgstr_w(info->wszLocaleName));
1901
1902 data->total++;
1903
1904 return TRUE;
1905 }
1906
1907 static HRESULT EnumRfc1766_create(LANGID LangId, IEnumRfc1766 **ppEnum)
1908 {
1909 EnumRfc1766_impl *rfc;
1910 struct enum_locales_data data;
1911
1912 TRACE("%04x, %p\n", LangId, ppEnum);
1913
1914 rfc = HeapAlloc( GetProcessHeap(), 0, sizeof(EnumRfc1766_impl) );
1915 rfc->vtbl_IEnumRfc1766 = &IEnumRfc1766_vtbl;
1916 rfc->ref = 1;
1917 rfc->pos = 0;
1918 rfc->total = 0;
1919
1920 data.total = 0;
1921 data.allocated = 32;
1922 data.info = HeapAlloc(GetProcessHeap(), 0, data.allocated * sizeof(RFC1766INFO));
1923 if (!data.info)
1924 {
1925 HeapFree(GetProcessHeap(), 0, rfc);
1926 return S_FALSE;
1927 }
1928
1929 TlsSetValue(MLANG_tls_index, &data);
1930 EnumSystemLocalesW(enum_locales_proc, 0/*LOCALE_SUPPORTED*/);
1931 TlsSetValue(MLANG_tls_index, NULL);
1932
1933 TRACE("enumerated %d rfc1766 structures\n", data.total);
1934
1935 if (!data.total)
1936 {
1937 HeapFree(GetProcessHeap(), 0, data.info);
1938 HeapFree(GetProcessHeap(), 0, rfc);
1939 return FALSE;
1940 }
1941
1942 rfc->info = data.info;
1943 rfc->total = data.total;
1944
1945 *ppEnum = (IEnumRfc1766 *)rfc;
1946 return S_OK;
1947 }
1948
1949 static HRESULT WINAPI fnIMultiLanguage_EnumRfc1766(
1950 IMultiLanguage *iface,
1951 IEnumRfc1766 **ppEnumRfc1766)
1952 {
1953 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1954 TRACE("%p %p\n", This, ppEnumRfc1766);
1955
1956 return EnumRfc1766_create(0, ppEnumRfc1766);
1957 }
1958
1959 /******************************************************************************/
1960
1961 static HRESULT WINAPI fnIMultiLanguage_GetRfc1766Info(
1962 IMultiLanguage* iface,
1963 LCID Locale,
1964 PRFC1766INFO pRfc1766Info)
1965 {
1966 FIXME("\n");
1967 return E_NOTIMPL;
1968 }
1969
1970 static HRESULT WINAPI fnIMultiLanguage_CreateConvertCharset(
1971 IMultiLanguage* iface,
1972 UINT uiSrcCodePage,
1973 UINT uiDstCodePage,
1974 DWORD dwProperty,
1975 IMLangConvertCharset** ppMLangConvertCharset)
1976 {
1977 FIXME("\n");
1978 return E_NOTIMPL;
1979 }
1980
1981 static const IMultiLanguageVtbl IMultiLanguage_vtbl =
1982 {
1983 fnIMultiLanguage_QueryInterface,
1984 fnIMultiLanguage_AddRef,
1985 fnIMultiLanguage_Release,
1986 fnIMultiLanguage_GetNumberOfCodePageInfo,
1987 fnIMultiLanguage_GetCodePageInfo,
1988 fnIMultiLanguage_GetFamilyCodePage,
1989 fnIMultiLanguage_EnumCodePages,
1990 fnIMultiLanguage_GetCharsetInfo,
1991 fnIMultiLanguage_IsConvertible,
1992 fnIMultiLanguage_ConvertString,
1993 fnIMultiLanguage_ConvertStringToUnicode,
1994 fnIMultiLanguage_ConvertStringFromUnicode,
1995 fnIMultiLanguage_ConvertStringReset,
1996 fnIMultiLanguage_GetRfc1766FromLcid,
1997 fnIMultiLanguage_GetLcidFromRfc1766,
1998 fnIMultiLanguage_EnumRfc1766,
1999 fnIMultiLanguage_GetRfc1766Info,
2000 fnIMultiLanguage_CreateConvertCharset,
2001 };
2002
2003
2004 /******************************************************************************/
2005
2006 static HRESULT WINAPI fnIMultiLanguage2_QueryInterface(
2007 IMultiLanguage3* iface,
2008 REFIID riid,
2009 void** ppvObject)
2010 {
2011 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2012 return MLang_QueryInterface( This, riid, ppvObject );
2013 }
2014
2015 static ULONG WINAPI fnIMultiLanguage2_AddRef( IMultiLanguage3* iface )
2016 {
2017 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2018 return MLang_AddRef( This );
2019 }
2020
2021 static ULONG WINAPI fnIMultiLanguage2_Release( IMultiLanguage3* iface )
2022 {
2023 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2024 return MLang_Release( This );
2025 }
2026
2027 static HRESULT WINAPI fnIMultiLanguage2_GetNumberOfCodePageInfo(
2028 IMultiLanguage3* iface,
2029 UINT* pcCodePage)
2030 {
2031 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2032 TRACE("%p, %p\n", This, pcCodePage);
2033
2034 if (!pcCodePage) return S_FALSE;
2035
2036 *pcCodePage = This->total_cp;
2037 return S_OK;
2038 }
2039
2040 static void fill_cp_info(const struct mlang_data *ml_data, UINT index, MIMECPINFO *mime_cp_info)
2041 {
2042 CHARSETINFO csi;
2043
2044 if (TranslateCharsetInfo((DWORD *)ml_data->family_codepage, &csi, TCI_SRCCODEPAGE))
2045 mime_cp_info->bGDICharset = csi.ciCharset;
2046 else
2047 mime_cp_info->bGDICharset = DEFAULT_CHARSET;
2048
2049 mime_cp_info->dwFlags = ml_data->mime_cp_info[index].flags;
2050 mime_cp_info->uiCodePage = ml_data->mime_cp_info[index].cp;
2051 mime_cp_info->uiFamilyCodePage = ml_data->family_codepage;
2052 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].description, -1,
2053 mime_cp_info->wszDescription, sizeof(mime_cp_info->wszDescription)/sizeof(WCHAR));
2054 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].web_charset, -1,
2055 mime_cp_info->wszWebCharset, sizeof(mime_cp_info->wszWebCharset)/sizeof(WCHAR));
2056 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].header_charset, -1,
2057 mime_cp_info->wszHeaderCharset, sizeof(mime_cp_info->wszHeaderCharset)/sizeof(WCHAR));
2058 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].body_charset, -1,
2059 mime_cp_info->wszBodyCharset, sizeof(mime_cp_info->wszBodyCharset)/sizeof(WCHAR));
2060
2061 MultiByteToWideChar(CP_ACP, 0, ml_data->fixed_font, -1,
2062 mime_cp_info->wszFixedWidthFont, sizeof(mime_cp_info->wszFixedWidthFont)/sizeof(WCHAR));
2063 MultiByteToWideChar(CP_ACP, 0, ml_data->proportional_font, -1,
2064 mime_cp_info->wszProportionalFont, sizeof(mime_cp_info->wszProportionalFont)/sizeof(WCHAR));
2065
2066 TRACE("%08x %u %u %s %s %s %s %s %s %d\n",
2067 mime_cp_info->dwFlags, mime_cp_info->uiCodePage,
2068 mime_cp_info->uiFamilyCodePage,
2069 wine_dbgstr_w(mime_cp_info->wszDescription),
2070 wine_dbgstr_w(mime_cp_info->wszWebCharset),
2071 wine_dbgstr_w(mime_cp_info->wszHeaderCharset),
2072 wine_dbgstr_w(mime_cp_info->wszBodyCharset),
2073 wine_dbgstr_w(mime_cp_info->wszFixedWidthFont),
2074 wine_dbgstr_w(mime_cp_info->wszProportionalFont),
2075 mime_cp_info->bGDICharset);
2076 }
2077
2078 static HRESULT WINAPI fnIMultiLanguage2_GetCodePageInfo(
2079 IMultiLanguage3* iface,
2080 UINT uiCodePage,
2081 LANGID LangId,
2082 PMIMECPINFO pCodePageInfo)
2083 {
2084 UINT i, n;
2085
2086 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2087 TRACE("%p, %u, %04x, %p\n", This, uiCodePage, LangId, pCodePageInfo);
2088
2089 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2090 {
2091 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2092 {
2093 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
2094 {
2095 fill_cp_info(&mlang_data[i], n, pCodePageInfo);
2096 return S_OK;
2097 }
2098 }
2099 }
2100
2101 return S_FALSE;
2102 }
2103
2104 static HRESULT WINAPI fnIMultiLanguage2_GetFamilyCodePage(
2105 IMultiLanguage3* iface,
2106 UINT uiCodePage,
2107 UINT* puiFamilyCodePage)
2108 {
2109 return GetFamilyCodePage(uiCodePage, puiFamilyCodePage);
2110 }
2111
2112 static HRESULT WINAPI fnIMultiLanguage2_EnumCodePages(
2113 IMultiLanguage3* iface,
2114 DWORD grfFlags,
2115 LANGID LangId,
2116 IEnumCodePage** ppEnumCodePage)
2117 {
2118 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2119 TRACE("%p %08x %04x %p\n", This, grfFlags, LangId, ppEnumCodePage);
2120
2121 return EnumCodePage_create( This, grfFlags, LangId, ppEnumCodePage );
2122 }
2123
2124 static HRESULT WINAPI fnIMultiLanguage2_GetCharsetInfo(
2125 IMultiLanguage3* iface,
2126 BSTR Charset,
2127 PMIMECSETINFO pCharsetInfo)
2128 {
2129 UINT i, n;
2130
2131 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2132 TRACE("%p %s %p\n", This, debugstr_w(Charset), pCharsetInfo);
2133
2134 if (!pCharsetInfo) return E_FAIL;
2135
2136 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2137 {
2138 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2139 {
2140 WCHAR csetW[MAX_MIMECSET_NAME];
2141
2142 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].mime_cp_info[n].web_charset, -1, csetW, MAX_MIMECSET_NAME);
2143 if (!lstrcmpiW(Charset, csetW))
2144 {
2145 pCharsetInfo->uiCodePage = mlang_data[i].family_codepage;
2146 pCharsetInfo->uiInternetEncoding = mlang_data[i].mime_cp_info[n].cp;
2147 strcpyW(pCharsetInfo->wszCharset, csetW);
2148 return S_OK;
2149 }
2150 }
2151 }
2152
2153 /* FIXME:
2154 * Since we do not support charsets like iso-2022-jp and do not have
2155 * them in our database as a primary (web_charset) encoding this loop
2156 * does an attempt to 'approximate' charset name by header_charset.
2157 */
2158 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2159 {
2160 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2161 {
2162 WCHAR csetW[MAX_MIMECSET_NAME];
2163
2164 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].mime_cp_info[n].header_charset, -1, csetW, MAX_MIMECSET_NAME);
2165 if (!lstrcmpiW(Charset, csetW))
2166 {
2167 pCharsetInfo->uiCodePage = mlang_data[i].family_codepage;
2168 pCharsetInfo->uiInternetEncoding = mlang_data[i].mime_cp_info[n].cp;
2169 strcpyW(pCharsetInfo->wszCharset, csetW);
2170 return S_OK;
2171 }
2172 }
2173 }
2174
2175 return E_FAIL;
2176 }
2177
2178 static HRESULT WINAPI fnIMultiLanguage2_IsConvertible(
2179 IMultiLanguage3* iface,
2180 DWORD dwSrcEncoding,
2181 DWORD dwDstEncoding)
2182 {
2183 return IsConvertINetStringAvailable(dwSrcEncoding, dwDstEncoding);
2184 }
2185
2186 static HRESULT WINAPI fnIMultiLanguage2_ConvertString(
2187 IMultiLanguage3* iface,
2188 DWORD* pdwMode,
2189 DWORD dwSrcEncoding,
2190 DWORD dwDstEncoding,
2191 BYTE* pSrcStr,
2192 UINT* pcSrcSize,
2193 BYTE* pDstStr,
2194 UINT* pcDstSize)
2195 {
2196 return ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding,
2197 (LPCSTR)pSrcStr, (LPINT)pcSrcSize, (LPSTR)pDstStr, (LPINT)pcDstSize);
2198 }
2199
2200 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicode(
2201 IMultiLanguage3* iface,
2202 DWORD* pdwMode,
2203 DWORD dwEncoding,
2204 CHAR* pSrcStr,
2205 UINT* pcSrcSize,
2206 WCHAR* pDstStr,
2207 UINT* pcDstSize)
2208 {
2209 return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
2210 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2211 }
2212
2213 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringFromUnicode(
2214 IMultiLanguage3* iface,
2215 DWORD* pdwMode,
2216 DWORD dwEncoding,
2217 WCHAR* pSrcStr,
2218 UINT* pcSrcSize,
2219 CHAR* pDstStr,
2220 UINT* pcDstSize)
2221 {
2222 return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
2223 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2224 }
2225
2226 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringReset(
2227 IMultiLanguage3* iface)
2228 {
2229 FIXME("\n");
2230 return E_NOTIMPL;
2231 }
2232
2233 static HRESULT WINAPI fnIMultiLanguage2_GetRfc1766FromLcid(
2234 IMultiLanguage3* iface,
2235 LCID lcid,
2236 BSTR* pbstrRfc1766)
2237 {
2238 WCHAR buf[MAX_RFC1766_NAME];
2239
2240 TRACE("%p %04x %p\n", iface, lcid, pbstrRfc1766);
2241
2242 if (lcid_to_rfc1766W( lcid, buf, MAX_RFC1766_NAME ))
2243 {
2244 *pbstrRfc1766 = SysAllocString( buf );
2245 return S_OK;
2246 }
2247 return E_FAIL;
2248 }
2249
2250 static HRESULT WINAPI fnIMultiLanguage2_GetLcidFromRfc1766(
2251 IMultiLanguage3* iface,
2252 LCID* pLocale,
2253 BSTR bstrRfc1766)
2254 {
2255 HRESULT hr;
2256 IEnumRfc1766 *rfc1766;
2257
2258 TRACE("%p %p %s\n", iface, pLocale, debugstr_w(bstrRfc1766));
2259
2260 if (!pLocale || !bstrRfc1766)
2261 return E_INVALIDARG;
2262
2263 hr = IMultiLanguage2_EnumRfc1766(iface, 0, &rfc1766);
2264 if (FAILED(hr))
2265 return hr;
2266
2267 hr = lcid_from_rfc1766(rfc1766, pLocale, bstrRfc1766);
2268
2269 IEnumRfc1766_Release(rfc1766);
2270 return hr;
2271 }
2272
2273 static HRESULT WINAPI fnIMultiLanguage2_EnumRfc1766(
2274 IMultiLanguage3* iface,
2275 LANGID LangId,
2276 IEnumRfc1766** ppEnumRfc1766)
2277 {
2278 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
2279 TRACE("%p %p\n", This, ppEnumRfc1766);
2280
2281 return EnumRfc1766_create(LangId, ppEnumRfc1766);
2282 }
2283
2284 static HRESULT WINAPI fnIMultiLanguage2_GetRfc1766Info(
2285 IMultiLanguage3* iface,
2286 LCID Locale,
2287 LANGID LangId,
2288 PRFC1766INFO pRfc1766Info)
2289 {
2290 FIXME("\n");
2291 return E_NOTIMPL;
2292 }
2293
2294 static HRESULT WINAPI fnIMultiLanguage2_CreateConvertCharset(
2295 IMultiLanguage3* iface,
2296 UINT uiSrcCodePage,
2297 UINT uiDstCodePage,
2298 DWORD dwProperty,
2299 IMLangConvertCharset** ppMLangConvertCharset)
2300 {
2301 FIXME("\n");
2302 return E_NOTIMPL;
2303 }
2304
2305 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringInIStream(
2306 IMultiLanguage3* iface,
2307 DWORD* pdwMode,
2308 DWORD dwFlag,
2309 WCHAR* lpFallBack,
2310 DWORD dwSrcEncoding,
2311 DWORD dwDstEncoding,
2312 IStream* pstmIn,
2313 IStream* pstmOut)
2314 {
2315 FIXME("\n");
2316 return E_NOTIMPL;
2317 }
2318
2319 /*
2320 * TODO: handle dwFlag and lpFallBack
2321 */
2322 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicodeEx(
2323 IMultiLanguage3* iface,
2324 DWORD* pdwMode,
2325 DWORD dwEncoding,
2326 CHAR* pSrcStr,
2327 UINT* pcSrcSize,
2328 WCHAR* pDstStr,
2329 UINT* pcDstSize,
2330 DWORD dwFlag,
2331 WCHAR* lpFallBack)
2332 {
2333 FIXME("\n");
2334 return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
2335 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2336 }
2337
2338 /*****************************************************************************
2339 * MultiLanguage2::ConvertStringToUnicodeEx
2340 *
2341 * Translates the multibyte string from the specified code page to Unicode.
2342 *
2343 * PARAMS
2344 * see ConvertStringToUnicode
2345 * dwFlag
2346 * lpFallBack if dwFlag contains MLCONVCHARF_USEDEFCHAR, lpFallBack string used
2347 * instead unconvertible characters.
2348 *
2349 * RETURNS
2350 * S_OK Success.
2351 * S_FALSE The conversion is not supported.
2352 * E_FAIL Some error has occurred.
2353 *
2354 * TODO: handle dwFlag and lpFallBack
2355 */
2356 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringFromUnicodeEx(
2357 IMultiLanguage3* This,
2358 DWORD* pdwMode,
2359 DWORD dwEncoding,
2360 WCHAR* pSrcStr,
2361 UINT* pcSrcSize,
2362 CHAR* pDstStr,
2363 UINT* pcDstSize,
2364 DWORD dwFlag,
2365 WCHAR* lpFallBack)
2366 {
2367 FIXME("\n");
2368 return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
2369 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2370 }
2371
2372 static HRESULT WINAPI fnIMultiLanguage2_DetectCodepageInIStream(
2373 IMultiLanguage3* iface,
2374 DWORD dwFlag,
2375 DWORD dwPrefWinCodePage,
2376 IStream* pstmIn,
2377 DetectEncodingInfo* lpEncoding,
2378 INT* pnScores)
2379 {
2380 FIXME("\n");
2381 return E_NOTIMPL;
2382 }
2383
2384 static HRESULT WINAPI fnIMultiLanguage2_DetectInputCodepage(
2385 IMultiLanguage3* iface,
2386 DWORD dwFlag,
2387 DWORD dwPrefWinCodePage,
2388 CHAR* pSrcStr,
2389 INT* pcSrcSize,
2390 DetectEncodingInfo* lpEncoding,
2391 INT* pnScores)
2392 {
2393 FIXME("\n");
2394 return E_NOTIMPL;
2395 }
2396
2397 static HRESULT WINAPI fnIMultiLanguage2_ValidateCodePage(
2398 IMultiLanguage3* iface,
2399 UINT uiCodePage,
2400 HWND hwnd)
2401 {
2402 FIXME("%u, %p\n", uiCodePage, hwnd);
2403 return E_NOTIMPL;
2404 }
2405
2406 static HRESULT WINAPI fnIMultiLanguage2_GetCodePageDescription(
2407 IMultiLanguage3* iface,
2408 UINT uiCodePage,
2409 LCID lcid,
2410 LPWSTR lpWideCharStr,
2411 int cchWideChar)
2412 {
2413 FIXME("%u, %04x, %p, %d\n", uiCodePage, lcid, lpWideCharStr, cchWideChar);
2414 return E_NOTIMPL;
2415 }
2416
2417 static HRESULT WINAPI fnIMultiLanguage2_IsCodePageInstallable(
2418 IMultiLanguage3* iface,
2419 UINT uiCodePage)
2420 {
2421 FIXME("%u\n", uiCodePage);
2422 return E_NOTIMPL;
2423 }
2424
2425 static HRESULT WINAPI fnIMultiLanguage2_SetMimeDBSource(
2426 IMultiLanguage3* iface,
2427 MIMECONTF dwSource)
2428 {
2429 FIXME("0x%08x\n", dwSource);
2430 return S_OK;
2431 }
2432
2433 static HRESULT WINAPI fnIMultiLanguage2_GetNumberOfScripts(
2434 IMultiLanguage3* iface,
2435 UINT* pnScripts)
2436 {
2437 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2438 TRACE("%p %p\n", This, pnScripts);
2439
2440 if (!pnScripts) return S_FALSE;
2441
2442 *pnScripts = This->total_scripts;
2443 return S_OK;
2444 }
2445
2446 static HRESULT WINAPI fnIMultiLanguage2_EnumScripts(
2447 IMultiLanguage3* iface,
2448 DWORD dwFlags,
2449 LANGID LangId,
2450 IEnumScript** ppEnumScript)
2451 {
2452 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2453 TRACE("%p %08x %04x %p\n", This, dwFlags, LangId, ppEnumScript);
2454
2455 return EnumScript_create( This, dwFlags, LangId, ppEnumScript );
2456 }
2457
2458 static HRESULT WINAPI fnIMultiLanguage2_ValidateCodePageEx(
2459 IMultiLanguage3* iface,
2460 UINT uiCodePage,
2461 HWND hwnd,
2462 DWORD dwfIODControl)
2463 {
2464 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2465 FIXME("%p %u %p %08x: stub!\n", This, uiCodePage, hwnd, dwfIODControl);
2466
2467 return S_FALSE;
2468 }
2469
2470 static HRESULT WINAPI fnIMultiLanguage3_DetectOutboundCodePage(
2471 IMultiLanguage3 *iface,
2472 DWORD dwFlags,
2473 LPCWSTR lpWideCharStr,
2474 UINT cchWideChar,
2475 UINT *puiPreferredCodePages,
2476 UINT nPreferredCodePages,
2477 UINT *puiDetectedCodePages,
2478 UINT *pnDetectedCodePages,
2479 WCHAR *lpSpecialChar)
2480 {
2481 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2482 FIXME("(%p)->(%08x %s %u %p %u %p %p %p)\n", This, dwFlags, debugstr_w(lpWideCharStr),
2483 cchWideChar, puiPreferredCodePages, nPreferredCodePages, puiDetectedCodePages,
2484 pnDetectedCodePages, lpSpecialChar);
2485 return E_NOTIMPL;
2486 }
2487
2488 static HRESULT WINAPI fnIMultiLanguage3_DetectOutboundCodePageInIStream(
2489 IMultiLanguage3 *iface,
2490 DWORD dwFlags,
2491 IStream *pStrIn,
2492 UINT *puiPreferredCodePages,
2493 UINT nPreferredCodePages,
2494 UINT *puiDetectedCodePages,
2495 UINT *pnDetectedCodePages,
2496 WCHAR *lpSpecialChar)
2497 {
2498 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2499 FIXME("(%p)->(%08x %p %p %u %p %p %p)\n", This, dwFlags, pStrIn,
2500 puiPreferredCodePages, nPreferredCodePages, puiDetectedCodePages,
2501 pnDetectedCodePages, lpSpecialChar);
2502 return E_NOTIMPL;
2503 }
2504
2505 static const IMultiLanguage3Vtbl IMultiLanguage3_vtbl =
2506 {
2507 fnIMultiLanguage2_QueryInterface,
2508 fnIMultiLanguage2_AddRef,
2509 fnIMultiLanguage2_Release,
2510 fnIMultiLanguage2_GetNumberOfCodePageInfo,
2511 fnIMultiLanguage2_GetCodePageInfo,
2512 fnIMultiLanguage2_GetFamilyCodePage,
2513 fnIMultiLanguage2_EnumCodePages,
2514 fnIMultiLanguage2_GetCharsetInfo,
2515 fnIMultiLanguage2_IsConvertible,
2516 fnIMultiLanguage2_ConvertString,
2517 fnIMultiLanguage2_ConvertStringToUnicode,
2518 fnIMultiLanguage2_ConvertStringFromUnicode,
2519 fnIMultiLanguage2_ConvertStringReset,
2520 fnIMultiLanguage2_GetRfc1766FromLcid,
2521 fnIMultiLanguage2_GetLcidFromRfc1766,
2522 fnIMultiLanguage2_EnumRfc1766,
2523 fnIMultiLanguage2_GetRfc1766Info,
2524 fnIMultiLanguage2_CreateConvertCharset,
2525 fnIMultiLanguage2_ConvertStringInIStream,
2526 fnIMultiLanguage2_ConvertStringToUnicodeEx,
2527 fnIMultiLanguage2_ConvertStringFromUnicodeEx,
2528 fnIMultiLanguage2_DetectCodepageInIStream,
2529 fnIMultiLanguage2_DetectInputCodepage,
2530 fnIMultiLanguage2_ValidateCodePage,
2531 fnIMultiLanguage2_GetCodePageDescription,
2532 fnIMultiLanguage2_IsCodePageInstallable,
2533 fnIMultiLanguage2_SetMimeDBSource,
2534 fnIMultiLanguage2_GetNumberOfScripts,
2535 fnIMultiLanguage2_EnumScripts,
2536 fnIMultiLanguage2_ValidateCodePageEx,
2537 fnIMultiLanguage3_DetectOutboundCodePage,
2538 fnIMultiLanguage3_DetectOutboundCodePageInIStream
2539 };
2540
2541 static HRESULT MultiLanguage_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2542 {
2543 MLang_impl *mlang;
2544 UINT i;
2545
2546 TRACE("Creating MultiLanguage object\n");
2547
2548 if( pUnkOuter )
2549 return CLASS_E_NOAGGREGATION;
2550
2551 mlang = HeapAlloc( GetProcessHeap(), 0, sizeof (MLang_impl) );
2552 mlang->vtbl_IMLangFontLink = &IMLangFontLink_vtbl;
2553 mlang->vtbl_IMultiLanguage = &IMultiLanguage_vtbl;
2554 mlang->vtbl_IMultiLanguage3 = &IMultiLanguage3_vtbl;
2555
2556 mlang->total_cp = 0;
2557 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2558 mlang->total_cp += mlang_data[i].number_of_cp;
2559
2560 /* do not enumerate unicode flavours */
2561 mlang->total_scripts = sizeof(mlang_data)/sizeof(mlang_data[0]) - 1;
2562
2563 mlang->ref = 1;
2564 *ppObj = (LPVOID) mlang;
2565 TRACE("returning %p\n", mlang);
2566
2567 LockModule();
2568
2569 return S_OK;
2570 }
2571
2572 /******************************************************************************/
2573
2574 HRESULT WINAPI DllCanUnloadNow(void)
2575 {
2576 return dll_count == 0 ? S_OK : S_FALSE;
2577 }
2578
2579 HRESULT WINAPI GetGlobalFontLinkObject(void)
2580 {
2581 FIXME("\n");
2582 return S_FALSE;
2583 }