?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus: Implemented GdipCreateBitmapFromResource.
[wine/gsoc_dplay.git] / dlls / mlang / mlang.c
blob14f881e050ce6f4899c53c7ddd864734393d98e3
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 INT destsz, size;
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 S_OK;
557
558 if (!pcSrcSize)
559 pcSrcSize = &src_len;
560
561 destsz = (pDstStr) ? *pcDstSize : 0;
562 *pcDstSize = 0;
563
564 if (!pSrcStr || !*pcSrcSize)
565 return S_OK;
566
567 if (*pcSrcSize == -1)
568 *pcSrcSize = lstrlenW(pSrcStr);
569
570 if (dwEncoding == CP_UNICODE)
571 {
572 if (*pcSrcSize == -1)
573 *pcSrcSize = lstrlenW(pSrcStr);
574
575 size = min(*pcSrcSize, destsz) * sizeof(WCHAR);
576 if (pDstStr)
577 memmove(pDstStr, pSrcStr, size);
578
579 if (size >= destsz)
580 goto fail;
581 }
582 else
583 {
584 size = WideCharToMultiByte(dwEncoding, 0, pSrcStr, *pcSrcSize,
585 NULL, 0, NULL, NULL);
586 if (!size)
587 goto fail;
588
589 if (pDstStr)
590 {
591 size = min(size, destsz);
592 size = WideCharToMultiByte(dwEncoding, 0, pSrcStr, *pcSrcSize,
593 pDstStr, destsz, NULL, NULL);
594 if (!size)
595 goto fail;
596 }
597 }
598
599 *pcDstSize = size;
600 return S_OK;
601
602 fail:
603 *pcSrcSize = 0;
604 *pcDstSize = 0;
605 return E_FAIL;
606 }
607
608 HRESULT WINAPI ConvertINetString(
609 LPDWORD pdwMode,
610 DWORD dwSrcEncoding,
611 DWORD dwDstEncoding,
612 LPCSTR pSrcStr,
613 LPINT pcSrcSize,
614 LPSTR pDstStr,
615 LPINT pcDstSize
616 )
617 {
618 TRACE("%p %d %d %s %p %p %p\n", pdwMode, dwSrcEncoding, dwDstEncoding,
619 debugstr_a(pSrcStr), pcSrcSize, pDstStr, pcDstSize);
620
621 if (dwSrcEncoding == CP_UNICODE)
622 {
623 INT cSrcSizeW;
624 if (pcSrcSize && *pcSrcSize != -1)
625 {
626 cSrcSizeW = *pcSrcSize / sizeof(WCHAR);
627 pcSrcSize = &cSrcSizeW;
628 }
629 return ConvertINetUnicodeToMultiByte(pdwMode, dwDstEncoding, (LPCWSTR)pSrcStr, pcSrcSize, pDstStr, pcDstSize);
630 }
631 else if (dwDstEncoding == CP_UNICODE)
632 {
633 HRESULT hr = ConvertINetMultiByteToUnicode(pdwMode, dwSrcEncoding, pSrcStr, pcSrcSize, (LPWSTR)pDstStr, pcDstSize);
634 *pcDstSize *= sizeof(WCHAR);
635 return hr;
636 }
637 else
638 {
639 INT cDstSizeW;
640 LPWSTR pDstStrW;
641 HRESULT hr;
642
643 TRACE("convert %s from %d to %d\n", debugstr_a(pSrcStr), dwSrcEncoding, dwDstEncoding);
644
645 hr = ConvertINetMultiByteToUnicode(pdwMode, dwSrcEncoding, pSrcStr, pcSrcSize, NULL, &cDstSizeW);
646 if (hr != S_OK)
647 return hr;
648
649 pDstStrW = HeapAlloc(GetProcessHeap(), 0, cDstSizeW * sizeof(WCHAR));
650 hr = ConvertINetMultiByteToUnicode(pdwMode, dwSrcEncoding, pSrcStr, pcSrcSize, pDstStrW, &cDstSizeW);
651 if (hr == S_OK)
652 hr = ConvertINetUnicodeToMultiByte(pdwMode, dwDstEncoding, pDstStrW, &cDstSizeW, pDstStr, pcDstSize);
653
654 HeapFree(GetProcessHeap(), 0, pDstStrW);
655 return hr;
656 }
657 }
658
659 static HRESULT GetFamilyCodePage(
660 UINT uiCodePage,
661 UINT* puiFamilyCodePage)
662 {
663 UINT i, n;
664
665 TRACE("%u %p\n", uiCodePage, puiFamilyCodePage);
666
667 if (!puiFamilyCodePage) return S_FALSE;
668
669 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
670 {
671 for (n = 0; n < mlang_data[i].number_of_cp; n++)
672 {
673 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
674 {
675 *puiFamilyCodePage = mlang_data[i].family_codepage;
676 return S_OK;
677 }
678 }
679 }
680
681 return S_FALSE;
682 }
683
684 HRESULT WINAPI IsConvertINetStringAvailable(
685 DWORD dwSrcEncoding,
686 DWORD dwDstEncoding)
687 {
688 UINT src_family, dst_family;
689
690 TRACE("%d %d\n", dwSrcEncoding, dwDstEncoding);
691
692 if (GetFamilyCodePage(dwSrcEncoding, &src_family) != S_OK ||
693 GetFamilyCodePage(dwDstEncoding, &dst_family) != S_OK)
694 return S_FALSE;
695
696 if (src_family == dst_family) return S_OK;
697
698 /* we can convert any codepage to/from unicode */
699 if (src_family == CP_UNICODE || dst_family == CP_UNICODE) return S_OK;
700
701 return S_FALSE;
702 }
703
704 static inline INT lcid_to_rfc1766A( LCID lcid, LPSTR rfc1766, INT len )
705 {
706 INT n = GetLocaleInfoA( lcid, LOCALE_SISO639LANGNAME, rfc1766, len );
707 if (n)
708 {
709 rfc1766[n - 1] = '-';
710 n += GetLocaleInfoA( lcid, LOCALE_SISO3166CTRYNAME, rfc1766 + n, len - n );
711 LCMapStringA( LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, rfc1766, n, rfc1766, len );
712 return n;
713 }
714 return 0;
715 }
716
717 static inline INT lcid_to_rfc1766W( LCID lcid, LPWSTR rfc1766, INT len )
718 {
719 INT n = GetLocaleInfoW( lcid, LOCALE_SISO639LANGNAME, rfc1766, len );
720 INT save = n;
721 if (n)
722 {
723 rfc1766[n - 1] = '-';
724 n += GetLocaleInfoW( lcid, LOCALE_SISO3166CTRYNAME, rfc1766 + n, len - n );
725 if (n == save)
726 rfc1766[n - 1] = '\0';
727 LCMapStringW( LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, rfc1766, n, rfc1766, len );
728 return n;
729 }
730 return 0;
731 }
732
733 HRESULT WINAPI LcidToRfc1766A(
734 LCID lcid,
735 LPSTR pszRfc1766,
736 INT nChar)
737 {
738 TRACE("%04x %p %u\n", lcid, pszRfc1766, nChar);
739
740 if (lcid_to_rfc1766A( lcid, pszRfc1766, nChar ))
741 return S_OK;
742
743 return S_FALSE;
744 }
745
746 HRESULT WINAPI LcidToRfc1766W(
747 LCID lcid,
748 LPWSTR pszRfc1766,
749 INT nChar)
750 {
751 TRACE("%04x %p %u\n", lcid, pszRfc1766, nChar);
752
753 if (lcid_to_rfc1766W( lcid, pszRfc1766, nChar ))
754 return S_OK;
755
756 return S_FALSE;
757 }
758
759 static HRESULT lcid_from_rfc1766(IEnumRfc1766 *iface, LCID *lcid, LPCWSTR rfc1766)
760 {
761 RFC1766INFO info;
762 ULONG num;
763
764 while (IEnumRfc1766_Next(iface, 1, &info, &num) == S_OK)
765 {
766 if (!strcmpW(info.wszRfc1766, rfc1766))
767 {
768 *lcid = info.lcid;
769 return S_OK;
770 }
771 if (strlenW(rfc1766) == 2 && !memcmp(info.wszRfc1766, rfc1766, 2 * sizeof(WCHAR)))
772 {
773 *lcid = PRIMARYLANGID(info.lcid);
774 return S_OK;
775 }
776 }
777
778 return E_FAIL;
779 }
780
781 HRESULT WINAPI Rfc1766ToLcidW(LCID *pLocale, LPCWSTR pszRfc1766)
782 {
783 IEnumRfc1766 *enumrfc1766;
784 HRESULT hr;
785
786 TRACE("(%p, %s)\n", pLocale, debugstr_w(pszRfc1766));
787
788 if (!pLocale || !pszRfc1766)
789 return E_INVALIDARG;
790
791 *pLocale = 0;
792
793 hr = EnumRfc1766_create(0, &enumrfc1766);
794 if (FAILED(hr))
795 return hr;
796
797 hr = lcid_from_rfc1766(enumrfc1766, pLocale, pszRfc1766);
798 IEnumRfc1766_Release(enumrfc1766);
799
800 return hr;
801 }
802
803 HRESULT WINAPI Rfc1766ToLcidA(LCID *lcid, LPCSTR rfc1766A)
804 {
805 WCHAR rfc1766W[MAX_RFC1766_NAME + 1];
806
807 MultiByteToWideChar(CP_ACP, 0, rfc1766A, -1, rfc1766W, MAX_RFC1766_NAME);
808 rfc1766W[MAX_RFC1766_NAME] = 0;
809
810 return Rfc1766ToLcidW(lcid, rfc1766W);
811 }
812
813 /******************************************************************************
814 * MLANG ClassFactory
815 */
816 typedef struct {
817 IClassFactory ITF_IClassFactory;
818
819 LONG ref;
820 HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
821 } IClassFactoryImpl;
822
823 struct object_creation_info
824 {
825 const CLSID *clsid;
826 LPCSTR szClassName;
827 HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
828 };
829
830 static const struct object_creation_info object_creation[] =
831 {
832 { &CLSID_CMultiLanguage, "CLSID_CMultiLanguage", MultiLanguage_create },
833 };
834
835 static HRESULT WINAPI
836 MLANGCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
837 {
838 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
839
840 TRACE("%s\n", debugstr_guid(riid) );
841
842 if (IsEqualGUID(riid, &IID_IUnknown)
843 || IsEqualGUID(riid, &IID_IClassFactory))
844 {
845 IClassFactory_AddRef(iface);
846 *ppobj = This;
847 return S_OK;
848 }
849
850 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
851 return E_NOINTERFACE;
852 }
853
854 static ULONG WINAPI MLANGCF_AddRef(LPCLASSFACTORY iface)
855 {
856 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
857 return InterlockedIncrement(&This->ref);
858 }
859
860 static ULONG WINAPI MLANGCF_Release(LPCLASSFACTORY iface)
861 {
862 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
863
864 ULONG ref = InterlockedDecrement(&This->ref);
865
866 if (ref == 0)
867 {
868 TRACE("Destroying %p\n", This);
869 HeapFree(GetProcessHeap(), 0, This);
870 }
871
872 return ref;
873 }
874
875 static HRESULT WINAPI MLANGCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter,
876 REFIID riid, LPVOID *ppobj)
877 {
878 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
879 HRESULT hres;
880 LPUNKNOWN punk;
881
882 TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
883
884 *ppobj = NULL;
885 hres = This->pfnCreateInstance(pOuter, (LPVOID *) &punk);
886 if (SUCCEEDED(hres)) {
887 hres = IUnknown_QueryInterface(punk, riid, ppobj);
888 IUnknown_Release(punk);
889 }
890 TRACE("returning (%p) -> %x\n", *ppobj, hres);
891 return hres;
892 }
893
894 static HRESULT WINAPI MLANGCF_LockServer(LPCLASSFACTORY iface,BOOL dolock)
895 {
896 if (dolock)
897 LockModule();
898 else
899 UnlockModule();
900
901 return S_OK;
902 }
903
904 static const IClassFactoryVtbl MLANGCF_Vtbl =
905 {
906 MLANGCF_QueryInterface,
907 MLANGCF_AddRef,
908 MLANGCF_Release,
909 MLANGCF_CreateInstance,
910 MLANGCF_LockServer
911 };
912
913 /******************************************************************
914 * DllGetClassObject (MLANG.@)
915 */
916 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
917 {
918 int i;
919 IClassFactoryImpl *factory;
920
921 TRACE("%s %s %p\n",debugstr_guid(rclsid), debugstr_guid(iid), ppv);
922
923 if ( !IsEqualGUID( &IID_IClassFactory, iid )
924 && ! IsEqualGUID( &IID_IUnknown, iid) )
925 return E_NOINTERFACE;
926
927 for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
928 {
929 if (IsEqualGUID(object_creation[i].clsid, rclsid))
930 break;
931 }
932
933 if (i == sizeof(object_creation)/sizeof(object_creation[0]))
934 {
935 FIXME("%s: no class found.\n", debugstr_guid(rclsid));
936 return CLASS_E_CLASSNOTAVAILABLE;
937 }
938
939 TRACE("Creating a class factory for %s\n",object_creation[i].szClassName);
940
941 factory = HeapAlloc(GetProcessHeap(), 0, sizeof(*factory));
942 if (factory == NULL) return E_OUTOFMEMORY;
943
944 factory->ITF_IClassFactory.lpVtbl = &MLANGCF_Vtbl;
945 factory->ref = 1;
946
947 factory->pfnCreateInstance = object_creation[i].pfnCreateInstance;
948
949 *ppv = &(factory->ITF_IClassFactory);
950
951 TRACE("(%p) <- %p\n", ppv, &(factory->ITF_IClassFactory) );
952
953 return S_OK;
954 }
955
956
957 /******************************************************************************/
958
959 typedef struct tagMLang_impl
960 {
961 const IMLangFontLinkVtbl *vtbl_IMLangFontLink;
962 const IMultiLanguageVtbl *vtbl_IMultiLanguage;
963 const IMultiLanguage3Vtbl *vtbl_IMultiLanguage3;
964 LONG ref;
965 DWORD total_cp, total_scripts;
966 } MLang_impl;
967
968 static ULONG WINAPI MLang_AddRef( MLang_impl* This)
969 {
970 return InterlockedIncrement(&This->ref);
971 }
972
973 static ULONG WINAPI MLang_Release( MLang_impl* This )
974 {
975 ULONG ref = InterlockedDecrement(&This->ref);
976
977 TRACE("%p ref = %d\n", This, ref);
978 if (ref == 0)
979 {
980 TRACE("Destroying %p\n", This);
981 HeapFree(GetProcessHeap(), 0, This);
982 UnlockModule();
983 }
984
985 return ref;
986 }
987
988 static HRESULT WINAPI MLang_QueryInterface(
989 MLang_impl* This,
990 REFIID riid,
991 void** ppvObject)
992 {
993 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
994
995 if (IsEqualGUID(riid, &IID_IUnknown)
996 || IsEqualGUID(riid, &IID_IMLangCodePages)
997 || IsEqualGUID(riid, &IID_IMLangFontLink))
998 {
999 MLang_AddRef(This);
1000 TRACE("Returning IID_IMLangFontLink %p ref = %d\n", This, This->ref);
1001 *ppvObject = &(This->vtbl_IMLangFontLink);
1002 return S_OK;
1003 }
1004
1005 if (IsEqualGUID(riid, &IID_IMultiLanguage) )
1006 {
1007 MLang_AddRef(This);
1008 TRACE("Returning IID_IMultiLanguage %p ref = %d\n", This, This->ref);
1009 *ppvObject = &(This->vtbl_IMultiLanguage);
1010 return S_OK;
1011 }
1012
1013 if (IsEqualGUID(riid, &IID_IMultiLanguage2) )
1014 {
1015 MLang_AddRef(This);
1016 *ppvObject = &(This->vtbl_IMultiLanguage3);
1017 TRACE("Returning IID_IMultiLanguage2 %p ref = %d\n", This, This->ref);
1018 return S_OK;
1019 }
1020
1021 if (IsEqualGUID(riid, &IID_IMultiLanguage3) )
1022 {
1023 MLang_AddRef(This);
1024 *ppvObject = &(This->vtbl_IMultiLanguage3);
1025 TRACE("Returning IID_IMultiLanguage3 %p ref = %d\n", This, This->ref);
1026 return S_OK;
1027 }
1028
1029 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1030 return E_NOINTERFACE;
1031 }
1032
1033 /******************************************************************************/
1034
1035 typedef struct tagEnumCodePage_impl
1036 {
1037 const IEnumCodePageVtbl *vtbl_IEnumCodePage;
1038 LONG ref;
1039 MIMECPINFO *cpinfo;
1040 DWORD total, pos;
1041 } EnumCodePage_impl;
1042
1043 static HRESULT WINAPI fnIEnumCodePage_QueryInterface(
1044 IEnumCodePage* iface,
1045 REFIID riid,
1046 void** ppvObject)
1047 {
1048 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1049
1050 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1051
1052 if (IsEqualGUID(riid, &IID_IUnknown)
1053 || IsEqualGUID(riid, &IID_IEnumCodePage))
1054 {
1055 IEnumCodePage_AddRef(iface);
1056 TRACE("Returning IID_IEnumCodePage %p ref = %d\n", This, This->ref);
1057 *ppvObject = &(This->vtbl_IEnumCodePage);
1058 return S_OK;
1059 }
1060
1061 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1062 return E_NOINTERFACE;
1063 }
1064
1065 static ULONG WINAPI fnIEnumCodePage_AddRef(
1066 IEnumCodePage* iface)
1067 {
1068 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1069 return InterlockedIncrement(&This->ref);
1070 }
1071
1072 static ULONG WINAPI fnIEnumCodePage_Release(
1073 IEnumCodePage* iface)
1074 {
1075 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1076 ULONG ref = InterlockedDecrement(&This->ref);
1077
1078 TRACE("%p ref = %d\n", This, ref);
1079 if (ref == 0)
1080 {
1081 TRACE("Destroying %p\n", This);
1082 HeapFree(GetProcessHeap(), 0, This->cpinfo);
1083 HeapFree(GetProcessHeap(), 0, This);
1084 }
1085
1086 return ref;
1087 }
1088
1089 static HRESULT WINAPI fnIEnumCodePage_Clone(
1090 IEnumCodePage* iface,
1091 IEnumCodePage** ppEnum)
1092 {
1093 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1094 FIXME("%p %p\n", This, ppEnum);
1095 return E_NOTIMPL;
1096 }
1097
1098 static HRESULT WINAPI fnIEnumCodePage_Next(
1099 IEnumCodePage* iface,
1100 ULONG celt,
1101 PMIMECPINFO rgelt,
1102 ULONG* pceltFetched)
1103 {
1104 ULONG i;
1105
1106 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1107 TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
1108
1109 if (!pceltFetched) return S_FALSE;
1110 *pceltFetched = 0;
1111
1112 if (!rgelt) return S_FALSE;
1113
1114 if (This->pos + celt > This->total)
1115 celt = This->total - This->pos;
1116
1117 if (!celt) return S_FALSE;
1118
1119 memcpy(rgelt, This->cpinfo + This->pos, celt * sizeof(MIMECPINFO));
1120 *pceltFetched = celt;
1121 This->pos += celt;
1122
1123 for (i = 0; i < celt; i++)
1124 {
1125 TRACE("#%u: %08x %u %u %s %s %s %s %s %s %d\n",
1126 i, rgelt[i].dwFlags, rgelt[i].uiCodePage,
1127 rgelt[i].uiFamilyCodePage,
1128 wine_dbgstr_w(rgelt[i].wszDescription),
1129 wine_dbgstr_w(rgelt[i].wszWebCharset),
1130 wine_dbgstr_w(rgelt[i].wszHeaderCharset),
1131 wine_dbgstr_w(rgelt[i].wszBodyCharset),
1132 wine_dbgstr_w(rgelt[i].wszFixedWidthFont),
1133 wine_dbgstr_w(rgelt[i].wszProportionalFont),
1134 rgelt[i].bGDICharset);
1135 }
1136 return S_OK;
1137 }
1138
1139 static HRESULT WINAPI fnIEnumCodePage_Reset(
1140 IEnumCodePage* iface)
1141 {
1142 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1143 TRACE("%p\n", This);
1144
1145 This->pos = 0;
1146 return S_OK;
1147 }
1148
1149 static HRESULT WINAPI fnIEnumCodePage_Skip(
1150 IEnumCodePage* iface,
1151 ULONG celt)
1152 {
1153 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1154 TRACE("%p %u\n", This, celt);
1155
1156 if (celt >= This->total) return S_FALSE;
1157
1158 This->pos += celt;
1159 return S_OK;
1160 }
1161
1162 static const IEnumCodePageVtbl IEnumCodePage_vtbl =
1163 {
1164 fnIEnumCodePage_QueryInterface,
1165 fnIEnumCodePage_AddRef,
1166 fnIEnumCodePage_Release,
1167 fnIEnumCodePage_Clone,
1168 fnIEnumCodePage_Next,
1169 fnIEnumCodePage_Reset,
1170 fnIEnumCodePage_Skip
1171 };
1172
1173 static HRESULT EnumCodePage_create( MLang_impl* mlang, DWORD grfFlags,
1174 LANGID LangId, IEnumCodePage** ppEnumCodePage )
1175 {
1176 EnumCodePage_impl *ecp;
1177 MIMECPINFO *cpinfo;
1178 UINT i, n;
1179
1180 TRACE("%p, %08x, %04x, %p\n", mlang, grfFlags, LangId, ppEnumCodePage);
1181
1182 if (!grfFlags) /* enumerate internal data base of encodings */
1183 grfFlags = MIMECONTF_MIME_LATEST;
1184
1185 ecp = HeapAlloc( GetProcessHeap(), 0, sizeof (EnumCodePage_impl) );
1186 ecp->vtbl_IEnumCodePage = &IEnumCodePage_vtbl;
1187 ecp->ref = 1;
1188 ecp->pos = 0;
1189 ecp->total = 0;
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 ecp->total++;
1196 }
1197 }
1198
1199 ecp->cpinfo = HeapAlloc(GetProcessHeap(), 0,
1200 sizeof(MIMECPINFO) * ecp->total);
1201 cpinfo = ecp->cpinfo;
1202
1203 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1204 {
1205 for (n = 0; n < mlang_data[i].number_of_cp; n++)
1206 {
1207 if (mlang_data[i].mime_cp_info[n].flags & grfFlags)
1208 fill_cp_info(&mlang_data[i], n, cpinfo++);
1209 }
1210 }
1211
1212 TRACE("enumerated %d codepages with flags %08x\n", ecp->total, grfFlags);
1213
1214 *ppEnumCodePage = (IEnumCodePage*) ecp;
1215
1216 return S_OK;
1217 }
1218
1219 /******************************************************************************/
1220
1221 typedef struct tagEnumScript_impl
1222 {
1223 const IEnumScriptVtbl *vtbl_IEnumScript;
1224 LONG ref;
1225 SCRIPTINFO *script_info;
1226 DWORD total, pos;
1227 } EnumScript_impl;
1228
1229 static HRESULT WINAPI fnIEnumScript_QueryInterface(
1230 IEnumScript* iface,
1231 REFIID riid,
1232 void** ppvObject)
1233 {
1234 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1235
1236 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1237
1238 if (IsEqualGUID(riid, &IID_IUnknown)
1239 || IsEqualGUID(riid, &IID_IEnumScript))
1240 {
1241 IEnumScript_AddRef(iface);
1242 TRACE("Returning IID_IEnumScript %p ref = %d\n", This, This->ref);
1243 *ppvObject = &(This->vtbl_IEnumScript);
1244 return S_OK;
1245 }
1246
1247 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1248 return E_NOINTERFACE;
1249 }
1250
1251 static ULONG WINAPI fnIEnumScript_AddRef(
1252 IEnumScript* iface)
1253 {
1254 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1255 return InterlockedIncrement(&This->ref);
1256 }
1257
1258 static ULONG WINAPI fnIEnumScript_Release(
1259 IEnumScript* iface)
1260 {
1261 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1262 ULONG ref = InterlockedDecrement(&This->ref);
1263
1264 TRACE("%p ref = %d\n", This, ref);
1265 if (ref == 0)
1266 {
1267 TRACE("Destroying %p\n", This);
1268 HeapFree(GetProcessHeap(), 0, This->script_info);
1269 HeapFree(GetProcessHeap(), 0, This);
1270 }
1271
1272 return ref;
1273 }
1274
1275 static HRESULT WINAPI fnIEnumScript_Clone(
1276 IEnumScript* iface,
1277 IEnumScript** ppEnum)
1278 {
1279 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1280 FIXME("%p %p: stub!\n", This, ppEnum);
1281 return E_NOTIMPL;
1282 }
1283
1284 static HRESULT WINAPI fnIEnumScript_Next(
1285 IEnumScript* iface,
1286 ULONG celt,
1287 PSCRIPTINFO rgelt,
1288 ULONG* pceltFetched)
1289 {
1290 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1291 TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
1292
1293 if (!pceltFetched || !rgelt) return E_FAIL;
1294
1295 *pceltFetched = 0;
1296
1297 if (This->pos + celt > This->total)
1298 celt = This->total - This->pos;
1299
1300 if (!celt) return S_FALSE;
1301
1302 memcpy(rgelt, This->script_info + This->pos, celt * sizeof(SCRIPTINFO));
1303 *pceltFetched = celt;
1304 This->pos += celt;
1305
1306 return S_OK;
1307 }
1308
1309 static HRESULT WINAPI fnIEnumScript_Reset(
1310 IEnumScript* iface)
1311 {
1312 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1313 TRACE("%p\n", This);
1314
1315 This->pos = 0;
1316 return S_OK;
1317 }
1318
1319 static HRESULT WINAPI fnIEnumScript_Skip(
1320 IEnumScript* iface,
1321 ULONG celt)
1322 {
1323 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1324 TRACE("%p %u\n", This, celt);
1325
1326 if (celt >= This->total) return S_FALSE;
1327
1328 This->pos += celt;
1329 return S_OK;
1330 }
1331
1332 static const IEnumScriptVtbl IEnumScript_vtbl =
1333 {
1334 fnIEnumScript_QueryInterface,
1335 fnIEnumScript_AddRef,
1336 fnIEnumScript_Release,
1337 fnIEnumScript_Clone,
1338 fnIEnumScript_Next,
1339 fnIEnumScript_Reset,
1340 fnIEnumScript_Skip
1341 };
1342
1343 static HRESULT EnumScript_create( MLang_impl* mlang, DWORD dwFlags,
1344 LANGID LangId, IEnumScript** ppEnumScript )
1345 {
1346 EnumScript_impl *es;
1347 UINT i;
1348
1349 TRACE("%p, %08x, %04x, %p: stub!\n", mlang, dwFlags, LangId, ppEnumScript);
1350
1351 if (!dwFlags) /* enumerate all available scripts */
1352 dwFlags = SCRIPTCONTF_SCRIPT_USER | SCRIPTCONTF_SCRIPT_HIDE | SCRIPTCONTF_SCRIPT_SYSTEM;
1353
1354 es = HeapAlloc( GetProcessHeap(), 0, sizeof (EnumScript_impl) );
1355 es->vtbl_IEnumScript = &IEnumScript_vtbl;
1356 es->ref = 1;
1357 es->pos = 0;
1358 /* do not enumerate unicode flavours */
1359 es->total = sizeof(mlang_data)/sizeof(mlang_data[0]) - 1;
1360 es->script_info = HeapAlloc(GetProcessHeap(), 0, sizeof(SCRIPTINFO) * es->total);
1361
1362 for (i = 0; i < es->total; i++)
1363 {
1364 es->script_info[i].ScriptId = i;
1365 es->script_info[i].uiCodePage = mlang_data[i].family_codepage;
1366 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].description, -1,
1367 es->script_info[i].wszDescription, MAX_SCRIPT_NAME);
1368 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].fixed_font, -1,
1369 es->script_info[i].wszFixedWidthFont, MAX_MIMEFACE_NAME);
1370 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].proportional_font, -1,
1371 es->script_info[i].wszProportionalFont, MAX_MIMEFACE_NAME);
1372 }
1373
1374 TRACE("enumerated %d scripts with flags %08x\n", es->total, dwFlags);
1375
1376 *ppEnumScript = (IEnumScript *)es;
1377
1378 return S_OK;
1379 }
1380
1381 /******************************************************************************/
1382
1383 static HRESULT WINAPI fnIMLangFontLink_QueryInterface(
1384 IMLangFontLink* iface,
1385 REFIID riid,
1386 void** ppvObject)
1387 {
1388 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1389 return MLang_QueryInterface( This, riid, ppvObject );
1390 }
1391
1392 static ULONG WINAPI fnIMLangFontLink_AddRef(
1393 IMLangFontLink* iface)
1394 {
1395 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1396 return MLang_AddRef( This );
1397 }
1398
1399 static ULONG WINAPI fnIMLangFontLink_Release(
1400 IMLangFontLink* iface)
1401 {
1402 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1403 return MLang_Release( This );
1404 }
1405
1406 static HRESULT WINAPI fnIMLangFontLink_GetCharCodePages(
1407 IMLangFontLink* iface,
1408 WCHAR chSrc,
1409 DWORD* pdwCodePages)
1410 {
1411 FIXME("\n");
1412 return E_NOTIMPL;
1413 }
1414
1415 static HRESULT WINAPI fnIMLangFontLink_GetStrCodePages(
1416 IMLangFontLink* iface,
1417 const WCHAR* pszSrc,
1418 long cchSrc,
1419 DWORD dwPriorityCodePages,
1420 DWORD* pdwCodePages,
1421 long* pcchCodePages)
1422 {
1423 FIXME("(pszSrc=%s, cchSrc=%ld, dwPriorityCodePages=%d) stub\n", debugstr_w(pszSrc), cchSrc, dwPriorityCodePages);
1424 *pdwCodePages = 0;
1425 *pcchCodePages = 1;
1426 return S_OK;
1427 }
1428
1429 static HRESULT WINAPI fnIMLangFontLink_CodePageToCodePages(
1430 IMLangFontLink* iface,
1431 UINT uCodePage,
1432 DWORD* pdwCodePages)
1433 {
1434 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1435 CHARSETINFO cs;
1436 BOOL rc;
1437
1438 TRACE("(%p) Seeking %u\n",This, uCodePage);
1439 memset(&cs, 0, sizeof(cs));
1440
1441 rc = TranslateCharsetInfo((DWORD*)uCodePage, &cs, TCI_SRCCODEPAGE);
1442
1443 if (rc)
1444 {
1445 *pdwCodePages = cs.fs.fsCsb[0];
1446 TRACE("resulting CodePages 0x%x\n",*pdwCodePages);
1447 }
1448 else
1449 TRACE("CodePage Not Found\n");
1450
1451 return S_OK;
1452 }
1453
1454 static HRESULT WINAPI fnIMLangFontLink_CodePagesToCodePage(
1455 IMLangFontLink* iface,
1456 DWORD dwCodePages,
1457 UINT uDefaultCodePage,
1458 UINT* puCodePage)
1459 {
1460 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1461 DWORD mask = 0x00000000;
1462 UINT i;
1463 CHARSETINFO cs;
1464 BOOL rc;
1465
1466 TRACE("(%p) scanning 0x%x default page %u\n",This, dwCodePages,
1467 uDefaultCodePage);
1468
1469 *puCodePage = 0x00000000;
1470
1471 rc = TranslateCharsetInfo((DWORD*)uDefaultCodePage, &cs, TCI_SRCCODEPAGE);
1472
1473 if (rc && (dwCodePages & cs.fs.fsCsb[0]))
1474 {
1475 TRACE("Found Default Codepage\n");
1476 *puCodePage = uDefaultCodePage;
1477 return S_OK;
1478 }
1479
1480
1481 for (i = 0; i < 32; i++)
1482 {
1483
1484 mask = 1 << i;
1485 if (dwCodePages & mask)
1486 {
1487 DWORD Csb[2];
1488 Csb[0] = mask;
1489 Csb[1] = 0x0;
1490 rc = TranslateCharsetInfo((DWORD*)Csb, &cs, TCI_SRCFONTSIG);
1491 if (!rc)
1492 continue;
1493
1494 TRACE("Falling back to least significant found CodePage %u\n",
1495 cs.ciACP);
1496 *puCodePage = cs.ciACP;
1497 return S_OK;
1498 }
1499 }
1500
1501 TRACE("no codepage found\n");
1502 return E_FAIL;
1503 }
1504
1505 static HRESULT WINAPI fnIMLangFontLink_GetFontCodePages(
1506 IMLangFontLink* iface,
1507 HDC hDC,
1508 HFONT hFont,
1509 DWORD* pdwCodePages)
1510 {
1511 HFONT old_font;
1512 FONTSIGNATURE fontsig;
1513 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1514
1515 TRACE("(%p)\n",This);
1516
1517 old_font = SelectObject(hDC,hFont);
1518 GetTextCharsetInfo(hDC,&fontsig, 0);
1519 SelectObject(hDC,old_font);
1520
1521 *pdwCodePages = fontsig.fsCsb[0];
1522 TRACE("CodePages is 0x%x\n",fontsig.fsCsb[0]);
1523
1524 return S_OK;
1525 }
1526
1527 static HRESULT WINAPI fnIMLangFontLink_MapFont(
1528 IMLangFontLink* iface,
1529 HDC hDC,
1530 DWORD dwCodePages,
1531 HFONT hSrcFont,
1532 HFONT* phDestFont)
1533 {
1534 FIXME("\n");
1535 return E_NOTIMPL;
1536 }
1537
1538 static HRESULT WINAPI fnIMLangFontLink_ReleaseFont(
1539 IMLangFontLink* iface,
1540 HFONT hFont)
1541 {
1542 FIXME("\n");
1543 return E_NOTIMPL;
1544 }
1545
1546 static HRESULT WINAPI fnIMLangFontLink_ResetFontMapping(
1547 IMLangFontLink* iface)
1548 {
1549 FIXME("\n");
1550 return E_NOTIMPL;
1551 }
1552
1553
1554 static const IMLangFontLinkVtbl IMLangFontLink_vtbl =
1555 {
1556 fnIMLangFontLink_QueryInterface,
1557 fnIMLangFontLink_AddRef,
1558 fnIMLangFontLink_Release,
1559 fnIMLangFontLink_GetCharCodePages,
1560 fnIMLangFontLink_GetStrCodePages,
1561 fnIMLangFontLink_CodePageToCodePages,
1562 fnIMLangFontLink_CodePagesToCodePage,
1563 fnIMLangFontLink_GetFontCodePages,
1564 fnIMLangFontLink_MapFont,
1565 fnIMLangFontLink_ReleaseFont,
1566 fnIMLangFontLink_ResetFontMapping,
1567 };
1568
1569 /******************************************************************************/
1570
1571 static HRESULT WINAPI fnIMultiLanguage_QueryInterface(
1572 IMultiLanguage* iface,
1573 REFIID riid,
1574 void** ppvObject)
1575 {
1576 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1577 return MLang_QueryInterface( This, riid, ppvObject );
1578 }
1579
1580 static ULONG WINAPI fnIMultiLanguage_AddRef( IMultiLanguage* iface )
1581 {
1582 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1583 return IMLangFontLink_AddRef( ((IMLangFontLink*)This) );
1584 }
1585
1586 static ULONG WINAPI fnIMultiLanguage_Release( IMultiLanguage* iface )
1587 {
1588 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1589 return IMLangFontLink_Release( ((IMLangFontLink*)This) );
1590 }
1591
1592 static HRESULT WINAPI fnIMultiLanguage_GetNumberOfCodePageInfo(
1593 IMultiLanguage* iface,
1594 UINT* pcCodePage)
1595 {
1596 FIXME("\n");
1597 return E_NOTIMPL;
1598 }
1599
1600 static HRESULT WINAPI fnIMultiLanguage_GetCodePageInfo(
1601 IMultiLanguage* iface,
1602 UINT uiCodePage,
1603 PMIMECPINFO pCodePageInfo)
1604 {
1605 UINT i, n;
1606
1607 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1608 TRACE("%p, %u, %p\n", This, uiCodePage, pCodePageInfo);
1609
1610 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1611 {
1612 for (n = 0; n < mlang_data[i].number_of_cp; n++)
1613 {
1614 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
1615 {
1616 fill_cp_info(&mlang_data[i], n, pCodePageInfo);
1617 return S_OK;
1618 }
1619 }
1620 }
1621
1622 return S_FALSE;
1623 }
1624
1625 static HRESULT WINAPI fnIMultiLanguage_GetFamilyCodePage(
1626 IMultiLanguage* iface,
1627 UINT uiCodePage,
1628 UINT* puiFamilyCodePage)
1629 {
1630 return GetFamilyCodePage(uiCodePage, puiFamilyCodePage);
1631 }
1632
1633 static HRESULT WINAPI fnIMultiLanguage_EnumCodePages(
1634 IMultiLanguage* iface,
1635 DWORD grfFlags,
1636 IEnumCodePage** ppEnumCodePage)
1637 {
1638 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1639 TRACE("%p %08x %p\n", This, grfFlags, ppEnumCodePage);
1640
1641 return EnumCodePage_create( This, grfFlags, 0, ppEnumCodePage );
1642 }
1643
1644 static HRESULT WINAPI fnIMultiLanguage_GetCharsetInfo(
1645 IMultiLanguage* iface,
1646 BSTR Charset,
1647 PMIMECSETINFO pCharsetInfo)
1648 {
1649 FIXME("\n");
1650 return E_NOTIMPL;
1651 }
1652
1653 static HRESULT WINAPI fnIMultiLanguage_IsConvertible(
1654 IMultiLanguage* iface,
1655 DWORD dwSrcEncoding,
1656 DWORD dwDstEncoding)
1657 {
1658 return IsConvertINetStringAvailable(dwSrcEncoding, dwDstEncoding);
1659 }
1660
1661 static HRESULT WINAPI fnIMultiLanguage_ConvertString(
1662 IMultiLanguage* iface,
1663 DWORD* pdwMode,
1664 DWORD dwSrcEncoding,
1665 DWORD dwDstEncoding,
1666 BYTE* pSrcStr,
1667 UINT* pcSrcSize,
1668 BYTE* pDstStr,
1669 UINT* pcDstSize)
1670 {
1671 return ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding,
1672 (LPCSTR)pSrcStr, (LPINT)pcSrcSize, (LPSTR)pDstStr, (LPINT)pcDstSize);
1673 }
1674
1675 static HRESULT WINAPI fnIMultiLanguage_ConvertStringToUnicode(
1676 IMultiLanguage* iface,
1677 DWORD* pdwMode,
1678 DWORD dwEncoding,
1679 CHAR* pSrcStr,
1680 UINT* pcSrcSize,
1681 WCHAR* pDstStr,
1682 UINT* pcDstSize)
1683 {
1684 return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
1685 (LPCSTR)pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
1686 }
1687
1688 static HRESULT WINAPI fnIMultiLanguage_ConvertStringFromUnicode(
1689 IMultiLanguage* iface,
1690 DWORD* pdwMode,
1691 DWORD dwEncoding,
1692 WCHAR* pSrcStr,
1693 UINT* pcSrcSize,
1694 CHAR* pDstStr,
1695 UINT* pcDstSize)
1696 {
1697 return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
1698 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
1699 }
1700
1701 static HRESULT WINAPI fnIMultiLanguage_ConvertStringReset(
1702 IMultiLanguage* iface)
1703 {
1704 FIXME("\n");
1705 return E_NOTIMPL;
1706 }
1707
1708 static HRESULT WINAPI fnIMultiLanguage_GetRfc1766FromLcid(
1709 IMultiLanguage* iface,
1710 LCID lcid,
1711 BSTR* pbstrRfc1766)
1712 {
1713 WCHAR buf[MAX_RFC1766_NAME];
1714
1715 TRACE("%p %04x %p\n", iface, lcid, pbstrRfc1766);
1716
1717 if (lcid_to_rfc1766W( lcid, buf, MAX_RFC1766_NAME ))
1718 {
1719 *pbstrRfc1766 = SysAllocString( buf );
1720 return S_OK;
1721 }
1722 return E_FAIL;
1723 }
1724
1725 static HRESULT WINAPI fnIMultiLanguage_GetLcidFromRfc1766(
1726 IMultiLanguage* iface,
1727 LCID* pLocale,
1728 BSTR bstrRfc1766)
1729 {
1730 HRESULT hr;
1731 IEnumRfc1766 *rfc1766;
1732
1733 TRACE("%p %p %s\n", iface, pLocale, debugstr_w(bstrRfc1766));
1734
1735 if (!pLocale || !bstrRfc1766)
1736 return E_INVALIDARG;
1737
1738 hr = IMultiLanguage_EnumRfc1766(iface, &rfc1766);
1739 if (FAILED(hr))
1740 return hr;
1741
1742 hr = lcid_from_rfc1766(rfc1766, pLocale, bstrRfc1766);
1743
1744 IEnumRfc1766_Release(rfc1766);
1745 return hr;
1746 }
1747
1748 /******************************************************************************/
1749
1750 typedef struct tagEnumRfc1766_impl
1751 {
1752 const IEnumRfc1766Vtbl *vtbl_IEnumRfc1766;
1753 LONG ref;
1754 RFC1766INFO *info;
1755 DWORD total, pos;
1756 } EnumRfc1766_impl;
1757
1758 static HRESULT WINAPI fnIEnumRfc1766_QueryInterface(
1759 IEnumRfc1766 *iface,
1760 REFIID riid,
1761 void** ppvObject)
1762 {
1763 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1764
1765 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1766
1767 if (IsEqualGUID(riid, &IID_IUnknown)
1768 || IsEqualGUID(riid, &IID_IEnumRfc1766))
1769 {
1770 IEnumRfc1766_AddRef(iface);
1771 TRACE("Returning IID_IEnumRfc1766 %p ref = %d\n", This, This->ref);
1772 *ppvObject = &(This->vtbl_IEnumRfc1766);
1773 return S_OK;
1774 }
1775
1776 WARN("(%p) -> (%s,%p), not found\n",This,debugstr_guid(riid),ppvObject);
1777 return E_NOINTERFACE;
1778 }
1779
1780 static ULONG WINAPI fnIEnumRfc1766_AddRef(
1781 IEnumRfc1766 *iface)
1782 {
1783 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1784 return InterlockedIncrement(&This->ref);
1785 }
1786
1787 static ULONG WINAPI fnIEnumRfc1766_Release(
1788 IEnumRfc1766 *iface)
1789 {
1790 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1791 ULONG ref = InterlockedDecrement(&This->ref);
1792
1793 TRACE("%p ref = %d\n", This, ref);
1794 if (ref == 0)
1795 {
1796 TRACE("Destroying %p\n", This);
1797 HeapFree(GetProcessHeap(), 0, This->info);
1798 HeapFree(GetProcessHeap(), 0, This);
1799 }
1800 return ref;
1801 }
1802
1803 static HRESULT WINAPI fnIEnumRfc1766_Clone(
1804 IEnumRfc1766 *iface,
1805 IEnumRfc1766 **ppEnum)
1806 {
1807 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1808 FIXME("%p %p\n", This, ppEnum);
1809 return E_NOTIMPL;
1810 }
1811
1812 static HRESULT WINAPI fnIEnumRfc1766_Next(
1813 IEnumRfc1766 *iface,
1814 ULONG celt,
1815 PRFC1766INFO rgelt,
1816 ULONG *pceltFetched)
1817 {
1818 ULONG i;
1819
1820 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1821 TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
1822
1823 if (!pceltFetched) return S_FALSE;
1824 *pceltFetched = 0;
1825
1826 if (!rgelt) return S_FALSE;
1827
1828 if (This->pos + celt > This->total)
1829 celt = This->total - This->pos;
1830
1831 if (!celt) return S_FALSE;
1832
1833 memcpy(rgelt, This->info + This->pos, celt * sizeof(RFC1766INFO));
1834 *pceltFetched = celt;
1835 This->pos += celt;
1836
1837 for (i = 0; i < celt; i++)
1838 {
1839 TRACE("#%u: %08x %s %s\n",
1840 i, rgelt[i].lcid,
1841 wine_dbgstr_w(rgelt[i].wszRfc1766),
1842 wine_dbgstr_w(rgelt[i].wszLocaleName));
1843 }
1844 return S_OK;
1845 }
1846
1847 static HRESULT WINAPI fnIEnumRfc1766_Reset(
1848 IEnumRfc1766 *iface)
1849 {
1850 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1851 TRACE("%p\n", This);
1852
1853 This->pos = 0;
1854 return S_OK;
1855 }
1856
1857 static HRESULT WINAPI fnIEnumRfc1766_Skip(
1858 IEnumRfc1766 *iface,
1859 ULONG celt)
1860 {
1861 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
1862 TRACE("%p %u\n", This, celt);
1863
1864 if (celt >= This->total) return S_FALSE;
1865
1866 This->pos += celt;
1867 return S_OK;
1868 }
1869
1870 static const IEnumRfc1766Vtbl IEnumRfc1766_vtbl =
1871 {
1872 fnIEnumRfc1766_QueryInterface,
1873 fnIEnumRfc1766_AddRef,
1874 fnIEnumRfc1766_Release,
1875 fnIEnumRfc1766_Clone,
1876 fnIEnumRfc1766_Next,
1877 fnIEnumRfc1766_Reset,
1878 fnIEnumRfc1766_Skip
1879 };
1880
1881 struct enum_locales_data
1882 {
1883 RFC1766INFO *info;
1884 DWORD total, allocated;
1885 };
1886
1887 static BOOL CALLBACK enum_locales_proc(LPWSTR locale)
1888 {
1889 WCHAR *end;
1890 struct enum_locales_data *data = TlsGetValue(MLANG_tls_index);
1891 RFC1766INFO *info;
1892
1893 TRACE("%s\n", debugstr_w(locale));
1894
1895 if (data->total >= data->allocated)
1896 {
1897 data->allocated += 32;
1898 data->info = HeapReAlloc(GetProcessHeap(), 0, data->info, data->allocated * sizeof(RFC1766INFO));
1899 if (!data->info) return FALSE;
1900 }
1901
1902 info = &data->info[data->total];
1903
1904 info->lcid = strtolW(locale, &end, 16);
1905 if (*end) /* invalid number */
1906 return FALSE;
1907
1908 info->wszRfc1766[0] = 0;
1909 lcid_to_rfc1766W( info->lcid, info->wszRfc1766, MAX_RFC1766_NAME );
1910
1911 info->wszLocaleName[0] = 0;
1912 GetLocaleInfoW(info->lcid, LOCALE_SLANGUAGE, info->wszLocaleName, MAX_LOCALE_NAME);
1913 TRACE("ISO639: %s SLANGUAGE: %s\n", wine_dbgstr_w(info->wszRfc1766), wine_dbgstr_w(info->wszLocaleName));
1914
1915 data->total++;
1916
1917 return TRUE;
1918 }
1919
1920 static HRESULT EnumRfc1766_create(LANGID LangId, IEnumRfc1766 **ppEnum)
1921 {
1922 EnumRfc1766_impl *rfc;
1923 struct enum_locales_data data;
1924
1925 TRACE("%04x, %p\n", LangId, ppEnum);
1926
1927 rfc = HeapAlloc( GetProcessHeap(), 0, sizeof(EnumRfc1766_impl) );
1928 rfc->vtbl_IEnumRfc1766 = &IEnumRfc1766_vtbl;
1929 rfc->ref = 1;
1930 rfc->pos = 0;
1931 rfc->total = 0;
1932
1933 data.total = 0;
1934 data.allocated = 32;
1935 data.info = HeapAlloc(GetProcessHeap(), 0, data.allocated * sizeof(RFC1766INFO));
1936 if (!data.info)
1937 {
1938 HeapFree(GetProcessHeap(), 0, rfc);
1939 return S_FALSE;
1940 }
1941
1942 TlsSetValue(MLANG_tls_index, &data);
1943 EnumSystemLocalesW(enum_locales_proc, 0/*LOCALE_SUPPORTED*/);
1944 TlsSetValue(MLANG_tls_index, NULL);
1945
1946 TRACE("enumerated %d rfc1766 structures\n", data.total);
1947
1948 if (!data.total)
1949 {
1950 HeapFree(GetProcessHeap(), 0, data.info);
1951 HeapFree(GetProcessHeap(), 0, rfc);
1952 return FALSE;
1953 }
1954
1955 rfc->info = data.info;
1956 rfc->total = data.total;
1957
1958 *ppEnum = (IEnumRfc1766 *)rfc;
1959 return S_OK;
1960 }
1961
1962 static HRESULT WINAPI fnIMultiLanguage_EnumRfc1766(
1963 IMultiLanguage *iface,
1964 IEnumRfc1766 **ppEnumRfc1766)
1965 {
1966 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1967 TRACE("%p %p\n", This, ppEnumRfc1766);
1968
1969 return EnumRfc1766_create(0, ppEnumRfc1766);
1970 }
1971
1972 /******************************************************************************/
1973
1974 static HRESULT WINAPI fnIMultiLanguage_GetRfc1766Info(
1975 IMultiLanguage* iface,
1976 LCID Locale,
1977 PRFC1766INFO pRfc1766Info)
1978 {
1979 FIXME("\n");
1980 return E_NOTIMPL;
1981 }
1982
1983 static HRESULT WINAPI fnIMultiLanguage_CreateConvertCharset(
1984 IMultiLanguage* iface,
1985 UINT uiSrcCodePage,
1986 UINT uiDstCodePage,
1987 DWORD dwProperty,
1988 IMLangConvertCharset** ppMLangConvertCharset)
1989 {
1990 FIXME("\n");
1991 return E_NOTIMPL;
1992 }
1993
1994 static const IMultiLanguageVtbl IMultiLanguage_vtbl =
1995 {
1996 fnIMultiLanguage_QueryInterface,
1997 fnIMultiLanguage_AddRef,
1998 fnIMultiLanguage_Release,
1999 fnIMultiLanguage_GetNumberOfCodePageInfo,
2000 fnIMultiLanguage_GetCodePageInfo,
2001 fnIMultiLanguage_GetFamilyCodePage,
2002 fnIMultiLanguage_EnumCodePages,
2003 fnIMultiLanguage_GetCharsetInfo,
2004 fnIMultiLanguage_IsConvertible,
2005 fnIMultiLanguage_ConvertString,
2006 fnIMultiLanguage_ConvertStringToUnicode,
2007 fnIMultiLanguage_ConvertStringFromUnicode,
2008 fnIMultiLanguage_ConvertStringReset,
2009 fnIMultiLanguage_GetRfc1766FromLcid,
2010 fnIMultiLanguage_GetLcidFromRfc1766,
2011 fnIMultiLanguage_EnumRfc1766,
2012 fnIMultiLanguage_GetRfc1766Info,
2013 fnIMultiLanguage_CreateConvertCharset,
2014 };
2015
2016
2017 /******************************************************************************/
2018
2019 static HRESULT WINAPI fnIMultiLanguage2_QueryInterface(
2020 IMultiLanguage3* iface,
2021 REFIID riid,
2022 void** ppvObject)
2023 {
2024 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2025 return MLang_QueryInterface( This, riid, ppvObject );
2026 }
2027
2028 static ULONG WINAPI fnIMultiLanguage2_AddRef( IMultiLanguage3* iface )
2029 {
2030 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2031 return MLang_AddRef( This );
2032 }
2033
2034 static ULONG WINAPI fnIMultiLanguage2_Release( IMultiLanguage3* iface )
2035 {
2036 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2037 return MLang_Release( This );
2038 }
2039
2040 static HRESULT WINAPI fnIMultiLanguage2_GetNumberOfCodePageInfo(
2041 IMultiLanguage3* iface,
2042 UINT* pcCodePage)
2043 {
2044 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2045 TRACE("%p, %p\n", This, pcCodePage);
2046
2047 if (!pcCodePage) return S_FALSE;
2048
2049 *pcCodePage = This->total_cp;
2050 return S_OK;
2051 }
2052
2053 static void fill_cp_info(const struct mlang_data *ml_data, UINT index, MIMECPINFO *mime_cp_info)
2054 {
2055 CHARSETINFO csi;
2056
2057 if (TranslateCharsetInfo((DWORD *)ml_data->family_codepage, &csi, TCI_SRCCODEPAGE))
2058 mime_cp_info->bGDICharset = csi.ciCharset;
2059 else
2060 mime_cp_info->bGDICharset = DEFAULT_CHARSET;
2061
2062 mime_cp_info->dwFlags = ml_data->mime_cp_info[index].flags;
2063 mime_cp_info->uiCodePage = ml_data->mime_cp_info[index].cp;
2064 mime_cp_info->uiFamilyCodePage = ml_data->family_codepage;
2065 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].description, -1,
2066 mime_cp_info->wszDescription, sizeof(mime_cp_info->wszDescription)/sizeof(WCHAR));
2067 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].web_charset, -1,
2068 mime_cp_info->wszWebCharset, sizeof(mime_cp_info->wszWebCharset)/sizeof(WCHAR));
2069 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].header_charset, -1,
2070 mime_cp_info->wszHeaderCharset, sizeof(mime_cp_info->wszHeaderCharset)/sizeof(WCHAR));
2071 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].body_charset, -1,
2072 mime_cp_info->wszBodyCharset, sizeof(mime_cp_info->wszBodyCharset)/sizeof(WCHAR));
2073
2074 MultiByteToWideChar(CP_ACP, 0, ml_data->fixed_font, -1,
2075 mime_cp_info->wszFixedWidthFont, sizeof(mime_cp_info->wszFixedWidthFont)/sizeof(WCHAR));
2076 MultiByteToWideChar(CP_ACP, 0, ml_data->proportional_font, -1,
2077 mime_cp_info->wszProportionalFont, sizeof(mime_cp_info->wszProportionalFont)/sizeof(WCHAR));
2078
2079 TRACE("%08x %u %u %s %s %s %s %s %s %d\n",
2080 mime_cp_info->dwFlags, mime_cp_info->uiCodePage,
2081 mime_cp_info->uiFamilyCodePage,
2082 wine_dbgstr_w(mime_cp_info->wszDescription),
2083 wine_dbgstr_w(mime_cp_info->wszWebCharset),
2084 wine_dbgstr_w(mime_cp_info->wszHeaderCharset),
2085 wine_dbgstr_w(mime_cp_info->wszBodyCharset),
2086 wine_dbgstr_w(mime_cp_info->wszFixedWidthFont),
2087 wine_dbgstr_w(mime_cp_info->wszProportionalFont),
2088 mime_cp_info->bGDICharset);
2089 }
2090
2091 static HRESULT WINAPI fnIMultiLanguage2_GetCodePageInfo(
2092 IMultiLanguage3* iface,
2093 UINT uiCodePage,
2094 LANGID LangId,
2095 PMIMECPINFO pCodePageInfo)
2096 {
2097 UINT i, n;
2098
2099 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2100 TRACE("%p, %u, %04x, %p\n", This, uiCodePage, LangId, pCodePageInfo);
2101
2102 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2103 {
2104 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2105 {
2106 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
2107 {
2108 fill_cp_info(&mlang_data[i], n, pCodePageInfo);
2109 return S_OK;
2110 }
2111 }
2112 }
2113
2114 return S_FALSE;
2115 }
2116
2117 static HRESULT WINAPI fnIMultiLanguage2_GetFamilyCodePage(
2118 IMultiLanguage3* iface,
2119 UINT uiCodePage,
2120 UINT* puiFamilyCodePage)
2121 {
2122 return GetFamilyCodePage(uiCodePage, puiFamilyCodePage);
2123 }
2124
2125 static HRESULT WINAPI fnIMultiLanguage2_EnumCodePages(
2126 IMultiLanguage3* iface,
2127 DWORD grfFlags,
2128 LANGID LangId,
2129 IEnumCodePage** ppEnumCodePage)
2130 {
2131 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2132 TRACE("%p %08x %04x %p\n", This, grfFlags, LangId, ppEnumCodePage);
2133
2134 return EnumCodePage_create( This, grfFlags, LangId, ppEnumCodePage );
2135 }
2136
2137 static HRESULT WINAPI fnIMultiLanguage2_GetCharsetInfo(
2138 IMultiLanguage3* iface,
2139 BSTR Charset,
2140 PMIMECSETINFO pCharsetInfo)
2141 {
2142 UINT i, n;
2143
2144 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2145 TRACE("%p %s %p\n", This, debugstr_w(Charset), pCharsetInfo);
2146
2147 if (!pCharsetInfo) return E_FAIL;
2148
2149 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2150 {
2151 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2152 {
2153 WCHAR csetW[MAX_MIMECSET_NAME];
2154
2155 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].mime_cp_info[n].web_charset, -1, csetW, MAX_MIMECSET_NAME);
2156 if (!lstrcmpiW(Charset, csetW))
2157 {
2158 pCharsetInfo->uiCodePage = mlang_data[i].family_codepage;
2159 pCharsetInfo->uiInternetEncoding = mlang_data[i].mime_cp_info[n].cp;
2160 strcpyW(pCharsetInfo->wszCharset, csetW);
2161 return S_OK;
2162 }
2163 }
2164 }
2165
2166 /* FIXME:
2167 * Since we do not support charsets like iso-2022-jp and do not have
2168 * them in our database as a primary (web_charset) encoding this loop
2169 * does an attempt to 'approximate' charset name by header_charset.
2170 */
2171 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2172 {
2173 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2174 {
2175 WCHAR csetW[MAX_MIMECSET_NAME];
2176
2177 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].mime_cp_info[n].header_charset, -1, csetW, MAX_MIMECSET_NAME);
2178 if (!lstrcmpiW(Charset, csetW))
2179 {
2180 pCharsetInfo->uiCodePage = mlang_data[i].family_codepage;
2181 pCharsetInfo->uiInternetEncoding = mlang_data[i].mime_cp_info[n].cp;
2182 strcpyW(pCharsetInfo->wszCharset, csetW);
2183 return S_OK;
2184 }
2185 }
2186 }
2187
2188 return E_FAIL;
2189 }
2190
2191 static HRESULT WINAPI fnIMultiLanguage2_IsConvertible(
2192 IMultiLanguage3* iface,
2193 DWORD dwSrcEncoding,
2194 DWORD dwDstEncoding)
2195 {
2196 return IsConvertINetStringAvailable(dwSrcEncoding, dwDstEncoding);
2197 }
2198
2199 static HRESULT WINAPI fnIMultiLanguage2_ConvertString(
2200 IMultiLanguage3* iface,
2201 DWORD* pdwMode,
2202 DWORD dwSrcEncoding,
2203 DWORD dwDstEncoding,
2204 BYTE* pSrcStr,
2205 UINT* pcSrcSize,
2206 BYTE* pDstStr,
2207 UINT* pcDstSize)
2208 {
2209 return ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding,
2210 (LPCSTR)pSrcStr, (LPINT)pcSrcSize, (LPSTR)pDstStr, (LPINT)pcDstSize);
2211 }
2212
2213 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicode(
2214 IMultiLanguage3* iface,
2215 DWORD* pdwMode,
2216 DWORD dwEncoding,
2217 CHAR* pSrcStr,
2218 UINT* pcSrcSize,
2219 WCHAR* pDstStr,
2220 UINT* pcDstSize)
2221 {
2222 return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
2223 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2224 }
2225
2226 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringFromUnicode(
2227 IMultiLanguage3* iface,
2228 DWORD* pdwMode,
2229 DWORD dwEncoding,
2230 WCHAR* pSrcStr,
2231 UINT* pcSrcSize,
2232 CHAR* pDstStr,
2233 UINT* pcDstSize)
2234 {
2235 return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
2236 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2237 }
2238
2239 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringReset(
2240 IMultiLanguage3* iface)
2241 {
2242 FIXME("\n");
2243 return E_NOTIMPL;
2244 }
2245
2246 static HRESULT WINAPI fnIMultiLanguage2_GetRfc1766FromLcid(
2247 IMultiLanguage3* iface,
2248 LCID lcid,
2249 BSTR* pbstrRfc1766)
2250 {
2251 WCHAR buf[MAX_RFC1766_NAME];
2252
2253 TRACE("%p %04x %p\n", iface, lcid, pbstrRfc1766);
2254
2255 if (lcid_to_rfc1766W( lcid, buf, MAX_RFC1766_NAME ))
2256 {
2257 *pbstrRfc1766 = SysAllocString( buf );
2258 return S_OK;
2259 }
2260 return E_FAIL;
2261 }
2262
2263 static HRESULT WINAPI fnIMultiLanguage2_GetLcidFromRfc1766(
2264 IMultiLanguage3* iface,
2265 LCID* pLocale,
2266 BSTR bstrRfc1766)
2267 {
2268 HRESULT hr;
2269 IEnumRfc1766 *rfc1766;
2270
2271 TRACE("%p %p %s\n", iface, pLocale, debugstr_w(bstrRfc1766));
2272
2273 if (!pLocale || !bstrRfc1766)
2274 return E_INVALIDARG;
2275
2276 hr = IMultiLanguage2_EnumRfc1766(iface, 0, &rfc1766);
2277 if (FAILED(hr))
2278 return hr;
2279
2280 hr = lcid_from_rfc1766(rfc1766, pLocale, bstrRfc1766);
2281
2282 IEnumRfc1766_Release(rfc1766);
2283 return hr;
2284 }
2285
2286 static HRESULT WINAPI fnIMultiLanguage2_EnumRfc1766(
2287 IMultiLanguage3* iface,
2288 LANGID LangId,
2289 IEnumRfc1766** ppEnumRfc1766)
2290 {
2291 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
2292 TRACE("%p %p\n", This, ppEnumRfc1766);
2293
2294 return EnumRfc1766_create(LangId, ppEnumRfc1766);
2295 }
2296
2297 static HRESULT WINAPI fnIMultiLanguage2_GetRfc1766Info(
2298 IMultiLanguage3* iface,
2299 LCID Locale,
2300 LANGID LangId,
2301 PRFC1766INFO pRfc1766Info)
2302 {
2303 FIXME("\n");
2304 return E_NOTIMPL;
2305 }
2306
2307 static HRESULT WINAPI fnIMultiLanguage2_CreateConvertCharset(
2308 IMultiLanguage3* iface,
2309 UINT uiSrcCodePage,
2310 UINT uiDstCodePage,
2311 DWORD dwProperty,
2312 IMLangConvertCharset** ppMLangConvertCharset)
2313 {
2314 FIXME("\n");
2315 return E_NOTIMPL;
2316 }
2317
2318 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringInIStream(
2319 IMultiLanguage3* iface,
2320 DWORD* pdwMode,
2321 DWORD dwFlag,
2322 WCHAR* lpFallBack,
2323 DWORD dwSrcEncoding,
2324 DWORD dwDstEncoding,
2325 IStream* pstmIn,
2326 IStream* pstmOut)
2327 {
2328 FIXME("\n");
2329 return E_NOTIMPL;
2330 }
2331
2332 /*
2333 * TODO: handle dwFlag and lpFallBack
2334 */
2335 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicodeEx(
2336 IMultiLanguage3* iface,
2337 DWORD* pdwMode,
2338 DWORD dwEncoding,
2339 CHAR* pSrcStr,
2340 UINT* pcSrcSize,
2341 WCHAR* pDstStr,
2342 UINT* pcDstSize,
2343 DWORD dwFlag,
2344 WCHAR* lpFallBack)
2345 {
2346 FIXME("\n");
2347 return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
2348 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2349 }
2350
2351 /*****************************************************************************
2352 * MultiLanguage2::ConvertStringToUnicodeEx
2353 *
2354 * Translates the multibyte string from the specified code page to Unicode.
2355 *
2356 * PARAMS
2357 * see ConvertStringToUnicode
2358 * dwFlag
2359 * lpFallBack if dwFlag contains MLCONVCHARF_USEDEFCHAR, lpFallBack string used
2360 * instead unconvertible characters.
2361 *
2362 * RETURNS
2363 * S_OK Success.
2364 * S_FALSE The conversion is not supported.
2365 * E_FAIL Some error has occurred.
2366 *
2367 * TODO: handle dwFlag and lpFallBack
2368 */
2369 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringFromUnicodeEx(
2370 IMultiLanguage3* This,
2371 DWORD* pdwMode,
2372 DWORD dwEncoding,
2373 WCHAR* pSrcStr,
2374 UINT* pcSrcSize,
2375 CHAR* pDstStr,
2376 UINT* pcDstSize,
2377 DWORD dwFlag,
2378 WCHAR* lpFallBack)
2379 {
2380 FIXME("\n");
2381 return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
2382 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2383 }
2384
2385 static HRESULT WINAPI fnIMultiLanguage2_DetectCodepageInIStream(
2386 IMultiLanguage3* iface,
2387 DWORD dwFlag,
2388 DWORD dwPrefWinCodePage,
2389 IStream* pstmIn,
2390 DetectEncodingInfo* lpEncoding,
2391 INT* pnScores)
2392 {
2393 FIXME("\n");
2394 return E_NOTIMPL;
2395 }
2396
2397 static HRESULT WINAPI fnIMultiLanguage2_DetectInputCodepage(
2398 IMultiLanguage3* iface,
2399 DWORD dwFlag,
2400 DWORD dwPrefWinCodePage,
2401 CHAR* pSrcStr,
2402 INT* pcSrcSize,
2403 DetectEncodingInfo* lpEncoding,
2404 INT* pnScores)
2405 {
2406 FIXME("\n");
2407 return E_NOTIMPL;
2408 }
2409
2410 static HRESULT WINAPI fnIMultiLanguage2_ValidateCodePage(
2411 IMultiLanguage3* iface,
2412 UINT uiCodePage,
2413 HWND hwnd)
2414 {
2415 FIXME("%u, %p\n", uiCodePage, hwnd);
2416 return E_NOTIMPL;
2417 }
2418
2419 static HRESULT WINAPI fnIMultiLanguage2_GetCodePageDescription(
2420 IMultiLanguage3* iface,
2421 UINT uiCodePage,
2422 LCID lcid,
2423 LPWSTR lpWideCharStr,
2424 int cchWideChar)
2425 {
2426 FIXME("%u, %04x, %p, %d\n", uiCodePage, lcid, lpWideCharStr, cchWideChar);
2427 return E_NOTIMPL;
2428 }
2429
2430 static HRESULT WINAPI fnIMultiLanguage2_IsCodePageInstallable(
2431 IMultiLanguage3* iface,
2432 UINT uiCodePage)
2433 {
2434 FIXME("%u\n", uiCodePage);
2435 return E_NOTIMPL;
2436 }
2437
2438 static HRESULT WINAPI fnIMultiLanguage2_SetMimeDBSource(
2439 IMultiLanguage3* iface,
2440 MIMECONTF dwSource)
2441 {
2442 FIXME("0x%08x\n", dwSource);
2443 return S_OK;
2444 }
2445
2446 static HRESULT WINAPI fnIMultiLanguage2_GetNumberOfScripts(
2447 IMultiLanguage3* iface,
2448 UINT* pnScripts)
2449 {
2450 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2451 TRACE("%p %p\n", This, pnScripts);
2452
2453 if (!pnScripts) return S_FALSE;
2454
2455 *pnScripts = This->total_scripts;
2456 return S_OK;
2457 }
2458
2459 static HRESULT WINAPI fnIMultiLanguage2_EnumScripts(
2460 IMultiLanguage3* iface,
2461 DWORD dwFlags,
2462 LANGID LangId,
2463 IEnumScript** ppEnumScript)
2464 {
2465 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2466 TRACE("%p %08x %04x %p\n", This, dwFlags, LangId, ppEnumScript);
2467
2468 return EnumScript_create( This, dwFlags, LangId, ppEnumScript );
2469 }
2470
2471 static HRESULT WINAPI fnIMultiLanguage2_ValidateCodePageEx(
2472 IMultiLanguage3* iface,
2473 UINT uiCodePage,
2474 HWND hwnd,
2475 DWORD dwfIODControl)
2476 {
2477 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2478 FIXME("%p %u %p %08x: stub!\n", This, uiCodePage, hwnd, dwfIODControl);
2479
2480 return S_FALSE;
2481 }
2482
2483 static HRESULT WINAPI fnIMultiLanguage3_DetectOutboundCodePage(
2484 IMultiLanguage3 *iface,
2485 DWORD dwFlags,
2486 LPCWSTR lpWideCharStr,
2487 UINT cchWideChar,
2488 UINT *puiPreferredCodePages,
2489 UINT nPreferredCodePages,
2490 UINT *puiDetectedCodePages,
2491 UINT *pnDetectedCodePages,
2492 WCHAR *lpSpecialChar)
2493 {
2494 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2495 FIXME("(%p)->(%08x %s %u %p %u %p %p %p)\n", This, dwFlags, debugstr_w(lpWideCharStr),
2496 cchWideChar, puiPreferredCodePages, nPreferredCodePages, puiDetectedCodePages,
2497 pnDetectedCodePages, lpSpecialChar);
2498 return E_NOTIMPL;
2499 }
2500
2501 static HRESULT WINAPI fnIMultiLanguage3_DetectOutboundCodePageInIStream(
2502 IMultiLanguage3 *iface,
2503 DWORD dwFlags,
2504 IStream *pStrIn,
2505 UINT *puiPreferredCodePages,
2506 UINT nPreferredCodePages,
2507 UINT *puiDetectedCodePages,
2508 UINT *pnDetectedCodePages,
2509 WCHAR *lpSpecialChar)
2510 {
2511 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2512 FIXME("(%p)->(%08x %p %p %u %p %p %p)\n", This, dwFlags, pStrIn,
2513 puiPreferredCodePages, nPreferredCodePages, puiDetectedCodePages,
2514 pnDetectedCodePages, lpSpecialChar);
2515 return E_NOTIMPL;
2516 }
2517
2518 static const IMultiLanguage3Vtbl IMultiLanguage3_vtbl =
2519 {
2520 fnIMultiLanguage2_QueryInterface,
2521 fnIMultiLanguage2_AddRef,
2522 fnIMultiLanguage2_Release,
2523 fnIMultiLanguage2_GetNumberOfCodePageInfo,
2524 fnIMultiLanguage2_GetCodePageInfo,
2525 fnIMultiLanguage2_GetFamilyCodePage,
2526 fnIMultiLanguage2_EnumCodePages,
2527 fnIMultiLanguage2_GetCharsetInfo,
2528 fnIMultiLanguage2_IsConvertible,
2529 fnIMultiLanguage2_ConvertString,
2530 fnIMultiLanguage2_ConvertStringToUnicode,
2531 fnIMultiLanguage2_ConvertStringFromUnicode,
2532 fnIMultiLanguage2_ConvertStringReset,
2533 fnIMultiLanguage2_GetRfc1766FromLcid,
2534 fnIMultiLanguage2_GetLcidFromRfc1766,
2535 fnIMultiLanguage2_EnumRfc1766,
2536 fnIMultiLanguage2_GetRfc1766Info,
2537 fnIMultiLanguage2_CreateConvertCharset,
2538 fnIMultiLanguage2_ConvertStringInIStream,
2539 fnIMultiLanguage2_ConvertStringToUnicodeEx,
2540 fnIMultiLanguage2_ConvertStringFromUnicodeEx,
2541 fnIMultiLanguage2_DetectCodepageInIStream,
2542 fnIMultiLanguage2_DetectInputCodepage,
2543 fnIMultiLanguage2_ValidateCodePage,
2544 fnIMultiLanguage2_GetCodePageDescription,
2545 fnIMultiLanguage2_IsCodePageInstallable,
2546 fnIMultiLanguage2_SetMimeDBSource,
2547 fnIMultiLanguage2_GetNumberOfScripts,
2548 fnIMultiLanguage2_EnumScripts,
2549 fnIMultiLanguage2_ValidateCodePageEx,
2550 fnIMultiLanguage3_DetectOutboundCodePage,
2551 fnIMultiLanguage3_DetectOutboundCodePageInIStream
2552 };
2553
2554 static HRESULT MultiLanguage_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2555 {
2556 MLang_impl *mlang;
2557 UINT i;
2558
2559 TRACE("Creating MultiLanguage object\n");
2560
2561 if( pUnkOuter )
2562 return CLASS_E_NOAGGREGATION;
2563
2564 mlang = HeapAlloc( GetProcessHeap(), 0, sizeof (MLang_impl) );
2565 mlang->vtbl_IMLangFontLink = &IMLangFontLink_vtbl;
2566 mlang->vtbl_IMultiLanguage = &IMultiLanguage_vtbl;
2567 mlang->vtbl_IMultiLanguage3 = &IMultiLanguage3_vtbl;
2568
2569 mlang->total_cp = 0;
2570 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2571 mlang->total_cp += mlang_data[i].number_of_cp;
2572
2573 /* do not enumerate unicode flavours */
2574 mlang->total_scripts = sizeof(mlang_data)/sizeof(mlang_data[0]) - 1;
2575
2576 mlang->ref = 1;
2577 *ppObj = (LPVOID) mlang;
2578 TRACE("returning %p\n", mlang);
2579
2580 LockModule();
2581
2582 return S_OK;
2583 }
2584
2585 /******************************************************************************/
2586
2587 HRESULT WINAPI DllCanUnloadNow(void)
2588 {
2589 return dll_count == 0 ? S_OK : S_FALSE;
2590 }
2591
2592 HRESULT WINAPI GetGlobalFontLinkObject(void)
2593 {
2594 FIXME("\n");
2595 return S_FALSE;
2596 }
DirectPlay implementation for GSoC