?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel32/tests: Print some more details on directory test failures.
[wine/multimedia.git] / dlls / mlang / mlang.c
blob424011d178611aff83717e5a4178f97bd073d92b
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 (Auto-Select)",
262 50932, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
263 MIMECONTF_IMPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
264 MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
265 "_autodetect", "_autodetect", "_autodetect" },
266 { "Japanese (EUC)",
267 51932, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
268 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
269 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
270 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
271 "euc-jp", "euc-jp", "euc-jp" },
272 { "Japanese (JIS)",
273 50220, MIMECONTF_IMPORT | MIMECONTF_MAILNEWS | MIMECONTF_EXPORT |
274 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_VALID_NLS |
275 MIMECONTF_PRIVCONVERTER | MIMECONTF_MIME_LATEST |
276 MIMECONTF_MIME_IE4,
277 "iso-2022-jp","iso-2022-jp","iso-2022-jp"},
278 { "Japanese (JIS 0208-1990 and 0212-1990)",
279 20932, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
280 MIMECONTF_VALID | MIMECONTF_PRIVCONVERTER | MIMECONTF_MIME_LATEST,
281 "EUC-JP","EUC-JP","EUC-JP"},
282 { "Japanese (JIS-Allow 1 byte Kana)",
283 50221, MIMECONTF_MAILNEWS | MIMECONTF_EXPORT | MIMECONTF_SAVABLE_BROWSER |
284 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_VALID_NLS |
285 MIMECONTF_VALID | MIMECONTF_PRIVCONVERTER | MIMECONTF_MIME_LATEST,
286 "csISO2022JP","iso-2022-jp","iso-2022-jp"},
287 { "Japanese (JIS-Allow 1 byte Kana - SO/SI)",
288 50222, MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_VALID |
289 MIMECONTF_PRIVCONVERTER | MIMECONTF_MIME_LATEST,
290 "iso-2022-jp","iso-2022-jp","iso-2022-jp"},
291 { "Japanese (Mac)",
292 10001, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
293 MIMECONTF_VALID | MIMECONTF_PRIVCONVERTER | MIMECONTF_MIME_LATEST,
294 "x-mac-japanese","x-mac-japanese","x-mac-japanese"},
295 { "Japanese (Shift-JIS)",
296 932, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
297 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
298 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
299 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
300 "shift_jis", "iso-2022-jp", "iso-2022-jp" }
301 };
302 static const MIME_CP_INFO korean_cp[] =
303 {
304 { "Korean",
305 949, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
306 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
307 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
308 MIMECONTF_MIME_LATEST,
309 "ks_c_5601-1987", "ks_c_5601-1987", "ks_c_5601-1987" }
310 };
311 static const MIME_CP_INFO thai_cp[] =
312 {
313 { "Thai (Windows)",
314 874, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_MIME_LATEST,
315 "ibm-thai", "ibm-thai", "ibm-thai" }
316 };
317 static const MIME_CP_INFO turkish_cp[] =
318 {
319 { "Turkish (DOS)",
320 857, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
321 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
322 "ibm857", "ibm857", "ibm857" },
323 { "IBM EBCDIC (Turkish Latin-5)",
324 1026, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
325 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
326 "ibm1026", "ibm1026", "ibm1026" },
327 { "Turkish (Windows)",
328 1254, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
329 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
330 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
331 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
332 "windows-1254", "windows-1254", "windows-1254" },
333 { "Turkish (Mac)",
334 10081, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
335 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
336 "x-mac-turkish", "x-mac-turkish", "x-mac-turkish" },
337 { "Latin 3 (ISO)",
338 28593, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT |
339 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_EXPORT | MIMECONTF_VALID |
340 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
341 "iso-8859-3", "iso-8859-3", "iso-8859-3" },
342 { "Turkish (ISO)",
343 28599, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
344 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
345 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
346 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
347 "iso-8859-9", "iso-8859-9", "iso-8859-9" }
348 };
349 static const MIME_CP_INFO vietnamese_cp[] =
350 {
351 { "Vietnamese (Windows)",
352 1258, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
353 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
354 MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 |
355 MIMECONTF_MIME_LATEST,
356 "windows-1258", "windows-1258", "windows-1258" }
357 };
358 static const MIME_CP_INFO western_cp[] =
359 {
360 { "IBM EBCDIC (US-Canada)",
361 37, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
362 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
363 "ibm037", "ibm037", "ibm037" },
364 { "OEM United States",
365 437, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
366 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
367 "ibm437", "ibm437", "ibm437" },
368 { "IBM EBCDIC (International)",
369 500, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
370 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
371 "ibm500", "ibm500", "ibm500" },
372 { "Western European (DOS)",
373 850, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
374 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
375 "ibm850", "ibm850", "ibm850" },
376 { "Portuguese (DOS)",
377 860, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
378 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
379 "ibm860", "ibm860", "ibm860" },
380 { "Icelandic (DOS)",
381 861, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
382 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
383 "ibm861", "ibm861", "ibm861" },
384 { "French Canadian (DOS)",
385 863, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
386 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
387 "ibm863", "ibm863", "ibm863" },
388 { "Nordic (DOS)",
389 865, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
390 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
391 "ibm865", "ibm865", "ibm865" },
392 { "Western European (Windows)",
393 1252, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
394 MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
395 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
396 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
397 "windows-1252", "windows-1252", "iso-8859-1" },
398 { "Western European (Mac)",
399 10000, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
400 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
401 "macintosh", "macintosh", "macintosh" },
402 { "Icelandic (Mac)",
403 10079, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
404 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
405 "x-mac-icelandic", "x-mac-icelandic", "x-mac-icelandic" },
406 { "US-ASCII",
407 20127, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT | MIMECONTF_EXPORT |
408 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_VALID |
409 MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
410 "us-ascii", "us-ascii", "us-ascii" },
411 { "Western European (ISO)",
412 28591, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
413 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
414 MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
415 MIMECONTF_MIME_LATEST,
416 "iso-8859-1", "iso-8859-1", "iso-8859-1" },
417 { "Latin 9 (ISO)",
418 28605, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT |
419 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
420 MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
421 MIMECONTF_MIME_LATEST,
422 "iso-8859-15", "iso-8859-15", "iso-8859-15" }
423 };
424 static const MIME_CP_INFO unicode_cp[] =
425 {
426 { "Unicode",
427 CP_UNICODE, MIMECONTF_MINIMAL | MIMECONTF_IMPORT |
428 MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
429 MIMECONTF_VALID | MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 |
430 MIMECONTF_MIME_LATEST,
431 "unicode", "unicode", "unicode" },
432 { "Unicode (UTF-7)",
433 CP_UTF7, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT |
434 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_EXPORT | MIMECONTF_VALID |
435 MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
436 "utf-7", "utf-7", "utf-7" },
437 { "Unicode (UTF-8)",
438 CP_UTF8, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
439 MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
440 MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
441 MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
442 "utf-8", "utf-8", "utf-8" }
443 };
444
445 static const struct mlang_data
446 {
447 const char *description;
448 UINT family_codepage;
449 UINT number_of_cp;
450 const MIME_CP_INFO *mime_cp_info;
451 const char *fixed_font;
452 const char *proportional_font;
453 SCRIPT_ID sid;
454 } mlang_data[] =
455 {
456 { "Arabic",1256,sizeof(arabic_cp)/sizeof(arabic_cp[0]),arabic_cp,
457 "Courier","Arial", sidArabic }, /* FIXME */
458 { "Baltic",1257,sizeof(baltic_cp)/sizeof(baltic_cp[0]),baltic_cp,
459 "Courier","Arial" }, /* FIXME */
460 { "Chinese Simplified",936,sizeof(chinese_simplified_cp)/sizeof(chinese_simplified_cp[0]),chinese_simplified_cp,
461 "Courier","Arial" }, /* FIXME */
462 { "Chinese Traditional",950,sizeof(chinese_traditional_cp)/sizeof(chinese_traditional_cp[0]),chinese_traditional_cp,
463 "Courier","Arial" }, /* FIXME */
464 { "Central European",1250,sizeof(central_european_cp)/sizeof(central_european_cp[0]),central_european_cp,
465 "Courier","Arial" }, /* FIXME */
466 { "Cyrillic",1251,sizeof(cyrillic_cp)/sizeof(cyrillic_cp[0]),cyrillic_cp,
467 "Courier","Arial", sidCyrillic }, /* FIXME */
468 { "Greek",1253,sizeof(greek_cp)/sizeof(greek_cp[0]),greek_cp,
469 "Courier","Arial", sidGreek }, /* FIXME */
470 { "Hebrew",1255,sizeof(hebrew_cp)/sizeof(hebrew_cp[0]),hebrew_cp,
471 "Courier","Arial", sidHebrew }, /* FIXME */
472 { "Japanese",932,sizeof(japanese_cp)/sizeof(japanese_cp[0]),japanese_cp,
473 "MS Gothic","MS PGothic" },
474 { "Korean",949,sizeof(korean_cp)/sizeof(korean_cp[0]),korean_cp,
475 "Courier","Arial" }, /* FIXME */
476 { "Thai",874,sizeof(thai_cp)/sizeof(thai_cp[0]),thai_cp,
477 "Courier","Arial", sidThai }, /* FIXME */
478 { "Turkish",1254,sizeof(turkish_cp)/sizeof(turkish_cp[0]),turkish_cp,
479 "Courier","Arial" }, /* FIXME */
480 { "Vietnamese",1258,sizeof(vietnamese_cp)/sizeof(vietnamese_cp[0]),vietnamese_cp,
481 "Courier","Arial" }, /* FIXME */
482 { "Western European",1252,sizeof(western_cp)/sizeof(western_cp[0]),western_cp,
483 "Courier","Arial", sidLatin }, /* FIXME */
484 { "Unicode",CP_UNICODE,sizeof(unicode_cp)/sizeof(unicode_cp[0]),unicode_cp,
485 "Courier","Arial" } /* FIXME */
486 };
487
488 static void fill_cp_info(const struct mlang_data *ml_data, UINT index, MIMECPINFO *mime_cp_info);
489
490 static LONG dll_count;
491
492 /*
493 * Japanese Detection and Converstion Functions
494 */
495
496 #define HANKATA(A) ((A >= 161) && (A <= 223))
497 #define ISEUC(A) ((A >= 161) && (A <= 254))
498 #define NOTEUC(A,B) (((A >= 129) && (A <= 159)) && ((B >= 64) && (B <= 160)))
499 #define SJIS1(A) (((A >= 129) && (A <= 159)) || ((A >= 224) && (A <= 239)))
500 #define SJIS2(A) ((A >= 64) && (A <= 252))
501 #define ISMARU(A) ((A >= 202) && (A <= 206))
502 #define ISNIGORI(A) (((A >= 182) && (A <= 196)) || ((A >= 202) && (A <= 206)))
503
504 static UINT DetectJapaneseCode(LPCSTR input, DWORD count)
505 {
506 UINT code = 0;
507 DWORD i = 0;
508 unsigned char c1,c2;
509
510 while ((code == 0 || code == 51932) && i < count)
511 {
512 c1 = input[i];
513 if (c1 == 0x1b /* ESC */)
514 {
515 i++;
516 if (i >= count)
517 return code;
518 c1 = input[i];
519 if (c1 == '$')
520 {
521 i++;
522 if (i >= count)
523 return code;
524 c1 = input[i];
525 if (c1 =='B' || c1 == '@')
526 code = 50220;
527 }
528 if (c1 == 'K')
529 code = 50220;
530 }
531 else if (c1 >= 129)
532 {
533 i++;
534 if (i >= count)
535 return code;
536 c2 = input[i];
537 if NOTEUC(c1,c2)
538 code = 932;
539 else if (ISEUC(c1) && ISEUC(c2))
540 code = 51932;
541 else if (((c1 == 142)) && HANKATA(c2))
542 code = 51932;
543 }
544 i++;
545 }
546 return code;
547 }
548
549 static inline void jis2sjis(unsigned char *p1, unsigned char *p2)
550 {
551 unsigned char c1 = *p1;
552 unsigned char c2 = *p2;
553 int row = c1 < 95 ? 112 : 176;
554 int cell = c1 % 2 ? 31 + (c2 > 95) : 126;
555
556 *p1 = ((c1 + 1) >> 1) + row;
557 *p2 = c2 + cell;
558 }
559
560 static inline void sjis2jis(unsigned char *p1, unsigned char *p2)
561 {
562 unsigned char c1 = *p1;
563 unsigned char c2 = *p2;
564 int shift = c2 < 159;
565 int row = c1 < 160 ? 112 : 176;
566 int cell = shift ? (31 + (c2 > 127)): 126;
567
568 *p1 = ((c1 - row) << 1) - shift;
569 *p2 -= cell;
570 }
571
572 static int han2zen(unsigned char *p1, unsigned char *p2)
573 {
574 int maru = FALSE;
575 int nigori = FALSE;
576 static const unsigned char char1[] = {129,129,129,129,129,131,131,131,131,
577 131,131,131,131,131,131,129,131,131,131,131,131,131,131,131,131,131,
578 131,131,131,131,131,131,131,131,131,131,131,131,131,131,131,131,131,
579 131,131,131,131,131,131,131,131,131,131,131,131,131,131,131,131,131,
580 131,129,129 };
581 static const unsigned char char2[] = {66,117,118,65,69,146,64,66,68,70,
582 72,131,133,135,98,91,65,67,69,71,73,74,76,78,80,82,84,86,88,90,92,94,
583 96,99,101,103,105,106,107,108,109,110,113,116,119,122,125,126,128,
584 129,130,132,134,136,137,138,139,140,141,143,147,74,75};
585
586 if (( *p2 == 222) && ((ISNIGORI(*p1) || (*p1 == 179))))
587 nigori = TRUE;
588 else if ((*p2 == 223) && (ISMARU(*p1)))
589 maru = TRUE;
590
591 if (*p1 >= 161 && *p1 <= 223)
592 {
593 unsigned char index = *p1 - 161;
594 *p1 = char1[index];
595 *p2 = char2[index];
596 }
597
598 if (maru || nigori)
599 {
600 if (nigori)
601 {
602 if (((*p2 >= 74) && (*p2 <= 103)) || ((*p2 >= 110) && (*p2 <= 122)))
603 (*p2)++;
604 else if ((*p1 == 131) && (*p2 == 69))
605 *p2 = 148;
606 }
607 else if ((maru) && ((*p2 >= 110) && (*p2 <= 122)))
608 *p2+= 2;
609
610 return 1;
611 }
612
613 return 0;
614 }
615
616
617 static UINT ConvertJIS2SJIS(LPCSTR input, DWORD count, LPSTR output)
618 {
619 DWORD i = 0;
620 int j = 0;
621 unsigned char p2,p;
622 int shifted = FALSE;
623
624 while (i < count)
625 {
626 p = input[i];
627 if (p == 0x1b /* ESC */)
628 {
629 i++;
630 if (i >= count)
631 return 0;
632 p2 = input[i];
633 if (p2 == '$' || p2 =='(')
634 i++;
635 if (p2 == 'K' || p2 =='$')
636 shifted = TRUE;
637 else
638 shifted = FALSE;
639 }
640 else
641 {
642 if (shifted)
643 {
644 i++;
645 if (i >= count)
646 return 0;
647 p2 = input[i];
648 jis2sjis(&p,&p2);
649 output[j++]=p;
650 output[j++]=p2;
651 }
652 else
653 {
654 output[j++] = p;
655 }
656 }
657 i++;
658 }
659 return j;
660 }
661
662 static inline int exit_shift(LPSTR out, int c)
663 {
664 if (out)
665 {
666 out[c] = 0x1b;
667 out[c+1] = '(';
668 out[c+2] = 'B';
669 }
670 return 3;
671 }
672
673 static inline int enter_shift(LPSTR out, int c)
674 {
675 if (out)
676 {
677 out[c] = 0x1b;
678 out[c+1] = '$';
679 out[c+2] = 'B';
680 }
681 return 3;
682 }
683
684
685 static UINT ConvertSJIS2JIS(LPCSTR input, DWORD count, LPSTR output)
686 {
687 DWORD i = 0;
688 int j = 0;
689 unsigned char p2,p;
690 int shifted = FALSE;
691
692 while (i < count)
693 {
694 p = input[i] & 0xff;
695 if (p == 10 || p == 13) /* NL and CR */
696 {
697 if (shifted)
698 {
699 shifted = FALSE;
700 j += exit_shift(output,j);
701 }
702 if (output)
703 output[j++] = p;
704 else
705 j++;
706 }
707 else
708 {
709 if (SJIS1(p))
710 {
711 i++;
712 if (i >= count)
713 return 0;
714 p2 = input[i] & 0xff;
715 if (SJIS2(p2))
716 {
717 sjis2jis(&p,&p2);
718 if (!shifted)
719 {
720 shifted = TRUE;
721 j+=enter_shift(output,j);
722 }
723 }
724
725 if (output)
726 {
727 output[j++]=p;
728 output[j++]=p2;
729 }
730 else
731 j+=2;
732 }
733 else
734 {
735 if (HANKATA(p))
736 {
737 if ((i+1) >= count)
738 return 0;
739 p2 = input[i+1] & 0xff;
740 i+=han2zen(&p,&p2);
741 sjis2jis(&p,&p2);
742 if (!shifted)
743 {
744 shifted = TRUE;
745 j+=enter_shift(output,j);
746 }
747 if (output)
748 {
749 output[j++]=p;
750 output[j++]=p2;
751 }
752 else
753 j+=2;
754 }
755 else
756 {
757 if (shifted)
758 {
759 shifted = FALSE;
760 j += exit_shift(output,j);
761 }
762 if (output)
763 output[j++]=p;
764 else
765 j++;
766 }
767 }
768 }
769 i++;
770 }
771 if (shifted)
772 j += exit_shift(output,j);
773 return j;
774 }
775
776 static UINT ConvertJISJapaneseToUnicode(LPCSTR input, DWORD count,
777 LPWSTR output, DWORD out_count)
778 {
779 CHAR *sjis_string;
780 UINT rc = 0;
781 sjis_string = HeapAlloc(GetProcessHeap(),0,count);
782 rc = ConvertJIS2SJIS(input,count,sjis_string);
783 if (rc)
784 {
785 TRACE("%s\n",debugstr_an(sjis_string,rc));
786 if (output)
787 rc = MultiByteToWideChar(932,0,sjis_string,rc,output,out_count);
788 else
789 rc = MultiByteToWideChar(932,0,sjis_string,rc,0,0);
790 }
791 HeapFree(GetProcessHeap(),0,sjis_string);
792 return rc;
793
794 }
795
796 static UINT ConvertUnknownJapaneseToUnicode(LPCSTR input, DWORD count,
797 LPWSTR output, DWORD out_count)
798 {
799 CHAR *sjis_string;
800 UINT rc = 0;
801 int code = DetectJapaneseCode(input,count);
802 TRACE("Japanese code %i\n",code);
803
804 if (code == 932)
805 {
806 if (output)
807 rc = MultiByteToWideChar(932,0,input,count,output,out_count);
808 else
809 rc = MultiByteToWideChar(932,0,input,count,0,0);
810 }
811 else if (code == 51932)
812 {
813 if (output)
814 rc = MultiByteToWideChar(20932,0,input,count,output,out_count);
815 else
816 rc = MultiByteToWideChar(20932,0,input,count,0,0);
817 }
818 else if (code == 50220)
819 {
820 sjis_string = HeapAlloc(GetProcessHeap(),0,count);
821 rc = ConvertJIS2SJIS(input,count,sjis_string);
822 if (rc)
823 {
824 TRACE("%s\n",debugstr_an(sjis_string,rc));
825 if (output)
826 rc = MultiByteToWideChar(932,0,sjis_string,rc,output,out_count);
827 else
828 rc = MultiByteToWideChar(932,0,sjis_string,rc,0,0);
829 }
830 HeapFree(GetProcessHeap(),0,sjis_string);
831 }
832 return rc;
833 }
834
835 static UINT ConvertJapaneseUnicodeToJIS(LPCWSTR input, DWORD count,
836 LPSTR output, DWORD out_count)
837 {
838 CHAR *sjis_string;
839 INT len;
840 UINT rc = 0;
841
842 len = WideCharToMultiByte(932,0,input,count,0,0,NULL,NULL);
843 sjis_string = HeapAlloc(GetProcessHeap(),0,len);
844 WideCharToMultiByte(932,0,input,count,sjis_string,len,NULL,NULL);
845 TRACE("%s\n",debugstr_an(sjis_string,len));
846
847 rc = ConvertSJIS2JIS(sjis_string, len, NULL);
848 if (out_count >= rc)
849 {
850 ConvertSJIS2JIS(sjis_string, len, output);
851 }
852 HeapFree(GetProcessHeap(),0,sjis_string);
853 return rc;
854
855 }
856
857 /*
858 * Dll lifetime tracking declaration
859 */
860 static void LockModule(void)
861 {
862 InterlockedIncrement(&dll_count);
863 }
864
865 static void UnlockModule(void)
866 {
867 InterlockedDecrement(&dll_count);
868 }
869
870 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
871 {
872 switch(fdwReason) {
873 case DLL_PROCESS_ATTACH:
874 MLANG_tls_index = TlsAlloc();
875 DisableThreadLibraryCalls(hInstDLL);
876 break;
877 case DLL_PROCESS_DETACH:
878 TlsFree(MLANG_tls_index);
879 break;
880 }
881 return TRUE;
882 }
883
884 HRESULT WINAPI ConvertINetMultiByteToUnicode(
885 LPDWORD pdwMode,
886 DWORD dwEncoding,
887 LPCSTR pSrcStr,
888 LPINT pcSrcSize,
889 LPWSTR pDstStr,
890 LPINT pcDstSize)
891 {
892 INT src_len = -1;
893
894 TRACE("%p %d %s %p %p %p\n", pdwMode, dwEncoding,
895 debugstr_a(pSrcStr), pcSrcSize, pDstStr, pcDstSize);
896
897 if (!pcDstSize)
898 return E_FAIL;
899
900 if (!pcSrcSize)
901 pcSrcSize = &src_len;
902
903 if (!*pcSrcSize)
904 {
905 *pcDstSize = 0;
906 return S_OK;
907 }
908
909 /* forwarding euc-jp to EUC-JP */
910 if (dwEncoding == 51932)
911 dwEncoding = 20932;
912
913 switch (dwEncoding)
914 {
915 case CP_UNICODE:
916 if (*pcSrcSize == -1)
917 *pcSrcSize = lstrlenW((LPCWSTR)pSrcStr);
918 *pcDstSize = min(*pcSrcSize, *pcDstSize);
919 *pcSrcSize *= sizeof(WCHAR);
920 if (pDstStr)
921 memmove(pDstStr, pSrcStr, *pcDstSize * sizeof(WCHAR));
922 break;
923
924 case 50220:
925 case 50221:
926 case 50222:
927 *pcDstSize = ConvertJISJapaneseToUnicode(pSrcStr,*pcSrcSize,pDstStr,*pcDstSize);
928 break;
929 case 50932:
930 *pcDstSize = ConvertUnknownJapaneseToUnicode(pSrcStr,*pcSrcSize,pDstStr,*pcDstSize);
931 break;
932
933 default:
934 if (*pcSrcSize == -1)
935 *pcSrcSize = lstrlenA(pSrcStr);
936
937 if (pDstStr)
938 *pcDstSize = MultiByteToWideChar(dwEncoding, 0, pSrcStr, *pcSrcSize, pDstStr, *pcDstSize);
939 else
940 *pcDstSize = MultiByteToWideChar(dwEncoding, 0, pSrcStr, *pcSrcSize, NULL, 0);
941 break;
942 }
943
944 if (!*pcDstSize)
945 return E_FAIL;
946
947 return S_OK;
948 }
949
950 HRESULT WINAPI ConvertINetUnicodeToMultiByte(
951 LPDWORD pdwMode,
952 DWORD dwEncoding,
953 LPCWSTR pSrcStr,
954 LPINT pcSrcSize,
955 LPSTR pDstStr,
956 LPINT pcDstSize)
957 {
958 INT destsz, size;
959 INT src_len = -1;
960
961 TRACE("%p %d %s %p %p %p\n", pdwMode, dwEncoding,
962 debugstr_w(pSrcStr), pcSrcSize, pDstStr, pcDstSize);
963
964 if (!pcDstSize)
965 return S_OK;
966
967 if (!pcSrcSize)
968 pcSrcSize = &src_len;
969
970 destsz = (pDstStr) ? *pcDstSize : 0;
971 *pcDstSize = 0;
972
973 if (!pSrcStr || !*pcSrcSize)
974 return S_OK;
975
976 if (*pcSrcSize == -1)
977 *pcSrcSize = lstrlenW(pSrcStr);
978
979 /* forwarding euc-jp to EUC-JP */
980 if (dwEncoding == 51932)
981 dwEncoding = 20932;
982
983 if (dwEncoding == CP_UNICODE)
984 {
985 if (*pcSrcSize == -1)
986 *pcSrcSize = lstrlenW(pSrcStr);
987
988 size = min(*pcSrcSize, destsz) * sizeof(WCHAR);
989 if (pDstStr)
990 memmove(pDstStr, pSrcStr, size);
991
992 if (size >= destsz)
993 goto fail;
994 }
995 else if (dwEncoding == 50220 || dwEncoding == 50221 || dwEncoding == 50222)
996 {
997 size = ConvertJapaneseUnicodeToJIS(pSrcStr, *pcSrcSize, NULL, 0);
998 if (!size)
999 goto fail;
1000
1001 if (pDstStr)
1002 {
1003 size = ConvertJapaneseUnicodeToJIS(pSrcStr, *pcSrcSize, pDstStr,
1004 destsz);
1005 if (!size)
1006 goto fail;
1007 }
1008
1009 }
1010 else
1011 {
1012 size = WideCharToMultiByte(dwEncoding, 0, pSrcStr, *pcSrcSize,
1013 NULL, 0, NULL, NULL);
1014 if (!size)
1015 goto fail;
1016
1017 if (pDstStr)
1018 {
1019 size = WideCharToMultiByte(dwEncoding, 0, pSrcStr, *pcSrcSize,
1020 pDstStr, destsz, NULL, NULL);
1021 if (!size)
1022 goto fail;
1023 }
1024 }
1025
1026 *pcDstSize = size;
1027 return S_OK;
1028
1029 fail:
1030 *pcSrcSize = 0;
1031 *pcDstSize = 0;
1032 return E_FAIL;
1033 }
1034
1035 HRESULT WINAPI ConvertINetString(
1036 LPDWORD pdwMode,
1037 DWORD dwSrcEncoding,
1038 DWORD dwDstEncoding,
1039 LPCSTR pSrcStr,
1040 LPINT pcSrcSize,
1041 LPSTR pDstStr,
1042 LPINT pcDstSize
1043 )
1044 {
1045 TRACE("%p %d %d %s %p %p %p\n", pdwMode, dwSrcEncoding, dwDstEncoding,
1046 debugstr_a(pSrcStr), pcSrcSize, pDstStr, pcDstSize);
1047
1048 if (dwSrcEncoding == CP_UNICODE)
1049 {
1050 INT cSrcSizeW;
1051 if (pcSrcSize && *pcSrcSize != -1)
1052 {
1053 cSrcSizeW = *pcSrcSize / sizeof(WCHAR);
1054 pcSrcSize = &cSrcSizeW;
1055 }
1056 return ConvertINetUnicodeToMultiByte(pdwMode, dwDstEncoding, (LPCWSTR)pSrcStr, pcSrcSize, pDstStr, pcDstSize);
1057 }
1058 else if (dwDstEncoding == CP_UNICODE)
1059 {
1060 HRESULT hr = ConvertINetMultiByteToUnicode(pdwMode, dwSrcEncoding, pSrcStr, pcSrcSize, (LPWSTR)pDstStr, pcDstSize);
1061 *pcDstSize *= sizeof(WCHAR);
1062 return hr;
1063 }
1064 else
1065 {
1066 INT cDstSizeW;
1067 LPWSTR pDstStrW;
1068 HRESULT hr;
1069
1070 TRACE("convert %s from %d to %d\n", debugstr_a(pSrcStr), dwSrcEncoding, dwDstEncoding);
1071
1072 hr = ConvertINetMultiByteToUnicode(pdwMode, dwSrcEncoding, pSrcStr, pcSrcSize, NULL, &cDstSizeW);
1073 if (hr != S_OK)
1074 return hr;
1075
1076 pDstStrW = HeapAlloc(GetProcessHeap(), 0, cDstSizeW * sizeof(WCHAR));
1077 hr = ConvertINetMultiByteToUnicode(pdwMode, dwSrcEncoding, pSrcStr, pcSrcSize, pDstStrW, &cDstSizeW);
1078 if (hr == S_OK)
1079 hr = ConvertINetUnicodeToMultiByte(pdwMode, dwDstEncoding, pDstStrW, &cDstSizeW, pDstStr, pcDstSize);
1080
1081 HeapFree(GetProcessHeap(), 0, pDstStrW);
1082 return hr;
1083 }
1084 }
1085
1086 static HRESULT GetFamilyCodePage(
1087 UINT uiCodePage,
1088 UINT* puiFamilyCodePage)
1089 {
1090 UINT i, n;
1091
1092 TRACE("%u %p\n", uiCodePage, puiFamilyCodePage);
1093
1094 if (!puiFamilyCodePage) return S_FALSE;
1095
1096 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1097 {
1098 for (n = 0; n < mlang_data[i].number_of_cp; n++)
1099 {
1100 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
1101 {
1102 *puiFamilyCodePage = mlang_data[i].family_codepage;
1103 return S_OK;
1104 }
1105 }
1106 }
1107
1108 return S_FALSE;
1109 }
1110
1111 HRESULT WINAPI IsConvertINetStringAvailable(
1112 DWORD dwSrcEncoding,
1113 DWORD dwDstEncoding)
1114 {
1115 UINT src_family, dst_family;
1116
1117 TRACE("%d %d\n", dwSrcEncoding, dwDstEncoding);
1118
1119 if (GetFamilyCodePage(dwSrcEncoding, &src_family) != S_OK ||
1120 GetFamilyCodePage(dwDstEncoding, &dst_family) != S_OK)
1121 return S_FALSE;
1122
1123 if (src_family == dst_family) return S_OK;
1124
1125 /* we can convert any codepage to/from unicode */
1126 if (src_family == CP_UNICODE || dst_family == CP_UNICODE) return S_OK;
1127
1128 return S_FALSE;
1129 }
1130
1131 static inline INT lcid_to_rfc1766A( LCID lcid, LPSTR rfc1766, INT len )
1132 {
1133 INT n = GetLocaleInfoA( lcid, LOCALE_SISO639LANGNAME, rfc1766, len );
1134 if (n)
1135 {
1136 rfc1766[n - 1] = '-';
1137 n += GetLocaleInfoA( lcid, LOCALE_SISO3166CTRYNAME, rfc1766 + n, len - n );
1138 LCMapStringA( LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, rfc1766, n, rfc1766, len );
1139 return n;
1140 }
1141 return 0;
1142 }
1143
1144 static inline INT lcid_to_rfc1766W( LCID lcid, LPWSTR rfc1766, INT len )
1145 {
1146 INT n = GetLocaleInfoW( lcid, LOCALE_SISO639LANGNAME, rfc1766, len );
1147 INT save = n;
1148 if (n)
1149 {
1150 rfc1766[n - 1] = '-';
1151 n += GetLocaleInfoW( lcid, LOCALE_SISO3166CTRYNAME, rfc1766 + n, len - n );
1152 if (n == save)
1153 rfc1766[n - 1] = '\0';
1154 LCMapStringW( LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, rfc1766, n, rfc1766, len );
1155 return n;
1156 }
1157 return 0;
1158 }
1159
1160 HRESULT WINAPI LcidToRfc1766A(
1161 LCID lcid,
1162 LPSTR pszRfc1766,
1163 INT nChar)
1164 {
1165 TRACE("%04x %p %u\n", lcid, pszRfc1766, nChar);
1166
1167 if (lcid_to_rfc1766A( lcid, pszRfc1766, nChar ))
1168 return S_OK;
1169
1170 return S_FALSE;
1171 }
1172
1173 HRESULT WINAPI LcidToRfc1766W(
1174 LCID lcid,
1175 LPWSTR pszRfc1766,
1176 INT nChar)
1177 {
1178 TRACE("%04x %p %u\n", lcid, pszRfc1766, nChar);
1179
1180 if (lcid_to_rfc1766W( lcid, pszRfc1766, nChar ))
1181 return S_OK;
1182
1183 return S_FALSE;
1184 }
1185
1186 static HRESULT lcid_from_rfc1766(IEnumRfc1766 *iface, LCID *lcid, LPCWSTR rfc1766)
1187 {
1188 RFC1766INFO info;
1189 ULONG num;
1190
1191 while (IEnumRfc1766_Next(iface, 1, &info, &num) == S_OK)
1192 {
1193 if (!strcmpW(info.wszRfc1766, rfc1766))
1194 {
1195 *lcid = info.lcid;
1196 return S_OK;
1197 }
1198 if (strlenW(rfc1766) == 2 && !memcmp(info.wszRfc1766, rfc1766, 2 * sizeof(WCHAR)))
1199 {
1200 *lcid = PRIMARYLANGID(info.lcid);
1201 return S_OK;
1202 }
1203 }
1204
1205 return E_FAIL;
1206 }
1207
1208 HRESULT WINAPI Rfc1766ToLcidW(LCID *pLocale, LPCWSTR pszRfc1766)
1209 {
1210 IEnumRfc1766 *enumrfc1766;
1211 HRESULT hr;
1212
1213 TRACE("(%p, %s)\n", pLocale, debugstr_w(pszRfc1766));
1214
1215 if (!pLocale || !pszRfc1766)
1216 return E_INVALIDARG;
1217
1218 *pLocale = 0;
1219
1220 hr = EnumRfc1766_create(0, &enumrfc1766);
1221 if (FAILED(hr))
1222 return hr;
1223
1224 hr = lcid_from_rfc1766(enumrfc1766, pLocale, pszRfc1766);
1225 IEnumRfc1766_Release(enumrfc1766);
1226
1227 return hr;
1228 }
1229
1230 HRESULT WINAPI Rfc1766ToLcidA(LCID *lcid, LPCSTR rfc1766A)
1231 {
1232 WCHAR rfc1766W[MAX_RFC1766_NAME + 1];
1233
1234 MultiByteToWideChar(CP_ACP, 0, rfc1766A, -1, rfc1766W, MAX_RFC1766_NAME);
1235 rfc1766W[MAX_RFC1766_NAME] = 0;
1236
1237 return Rfc1766ToLcidW(lcid, rfc1766W);
1238 }
1239
1240 /******************************************************************************
1241 * MLANG ClassFactory
1242 */
1243 typedef struct {
1244 IClassFactory ITF_IClassFactory;
1245
1246 LONG ref;
1247 HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
1248 } IClassFactoryImpl;
1249
1250 struct object_creation_info
1251 {
1252 const CLSID *clsid;
1253 LPCSTR szClassName;
1254 HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
1255 };
1256
1257 static const struct object_creation_info object_creation[] =
1258 {
1259 { &CLSID_CMultiLanguage, "CLSID_CMultiLanguage", MultiLanguage_create },
1260 };
1261
1262 static HRESULT WINAPI
1263 MLANGCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
1264 {
1265 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
1266
1267 TRACE("%s\n", debugstr_guid(riid) );
1268
1269 if (IsEqualGUID(riid, &IID_IUnknown)
1270 || IsEqualGUID(riid, &IID_IClassFactory))
1271 {
1272 IClassFactory_AddRef(iface);
1273 *ppobj = This;
1274 return S_OK;
1275 }
1276
1277 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
1278 return E_NOINTERFACE;
1279 }
1280
1281 static ULONG WINAPI MLANGCF_AddRef(LPCLASSFACTORY iface)
1282 {
1283 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
1284 return InterlockedIncrement(&This->ref);
1285 }
1286
1287 static ULONG WINAPI MLANGCF_Release(LPCLASSFACTORY iface)
1288 {
1289 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
1290
1291 ULONG ref = InterlockedDecrement(&This->ref);
1292
1293 if (ref == 0)
1294 {
1295 TRACE("Destroying %p\n", This);
1296 HeapFree(GetProcessHeap(), 0, This);
1297 }
1298
1299 return ref;
1300 }
1301
1302 static HRESULT WINAPI MLANGCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter,
1303 REFIID riid, LPVOID *ppobj)
1304 {
1305 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
1306 HRESULT hres;
1307 LPUNKNOWN punk;
1308
1309 TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
1310
1311 *ppobj = NULL;
1312 hres = This->pfnCreateInstance(pOuter, (LPVOID *) &punk);
1313 if (SUCCEEDED(hres)) {
1314 hres = IUnknown_QueryInterface(punk, riid, ppobj);
1315 IUnknown_Release(punk);
1316 }
1317 TRACE("returning (%p) -> %x\n", *ppobj, hres);
1318 return hres;
1319 }
1320
1321 static HRESULT WINAPI MLANGCF_LockServer(LPCLASSFACTORY iface,BOOL dolock)
1322 {
1323 if (dolock)
1324 LockModule();
1325 else
1326 UnlockModule();
1327
1328 return S_OK;
1329 }
1330
1331 static const IClassFactoryVtbl MLANGCF_Vtbl =
1332 {
1333 MLANGCF_QueryInterface,
1334 MLANGCF_AddRef,
1335 MLANGCF_Release,
1336 MLANGCF_CreateInstance,
1337 MLANGCF_LockServer
1338 };
1339
1340 /******************************************************************
1341 * DllGetClassObject (MLANG.@)
1342 */
1343 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
1344 {
1345 unsigned int i;
1346 IClassFactoryImpl *factory;
1347
1348 TRACE("%s %s %p\n",debugstr_guid(rclsid), debugstr_guid(iid), ppv);
1349
1350 if ( !IsEqualGUID( &IID_IClassFactory, iid )
1351 && ! IsEqualGUID( &IID_IUnknown, iid) )
1352 return E_NOINTERFACE;
1353
1354 for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
1355 {
1356 if (IsEqualGUID(object_creation[i].clsid, rclsid))
1357 break;
1358 }
1359
1360 if (i == sizeof(object_creation)/sizeof(object_creation[0]))
1361 {
1362 FIXME("%s: no class found.\n", debugstr_guid(rclsid));
1363 return CLASS_E_CLASSNOTAVAILABLE;
1364 }
1365
1366 TRACE("Creating a class factory for %s\n",object_creation[i].szClassName);
1367
1368 factory = HeapAlloc(GetProcessHeap(), 0, sizeof(*factory));
1369 if (factory == NULL) return E_OUTOFMEMORY;
1370
1371 factory->ITF_IClassFactory.lpVtbl = &MLANGCF_Vtbl;
1372 factory->ref = 1;
1373
1374 factory->pfnCreateInstance = object_creation[i].pfnCreateInstance;
1375
1376 *ppv = &(factory->ITF_IClassFactory);
1377
1378 TRACE("(%p) <- %p\n", ppv, &(factory->ITF_IClassFactory) );
1379
1380 return S_OK;
1381 }
1382
1383
1384 /******************************************************************************/
1385
1386 typedef struct tagMLang_impl
1387 {
1388 const IMLangFontLinkVtbl *vtbl_IMLangFontLink;
1389 const IMultiLanguageVtbl *vtbl_IMultiLanguage;
1390 const IMultiLanguage3Vtbl *vtbl_IMultiLanguage3;
1391 const IMLangFontLink2Vtbl *vtbl_IMLangFontLink2;
1392 const IMLangLineBreakConsoleVtbl *vtbl_IMLangLineBreakConsole;
1393 LONG ref;
1394 DWORD total_cp, total_scripts;
1395 } MLang_impl;
1396
1397 static ULONG MLang_AddRef( MLang_impl* This)
1398 {
1399 return InterlockedIncrement(&This->ref);
1400 }
1401
1402 static ULONG MLang_Release( MLang_impl* This )
1403 {
1404 ULONG ref = InterlockedDecrement(&This->ref);
1405
1406 TRACE("%p ref = %d\n", This, ref);
1407 if (ref == 0)
1408 {
1409 TRACE("Destroying %p\n", This);
1410 HeapFree(GetProcessHeap(), 0, This);
1411 UnlockModule();
1412 }
1413
1414 return ref;
1415 }
1416
1417 static HRESULT MLang_QueryInterface(
1418 MLang_impl* This,
1419 REFIID riid,
1420 void** ppvObject)
1421 {
1422 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1423
1424 if (IsEqualGUID(riid, &IID_IUnknown)
1425 || IsEqualGUID(riid, &IID_IMLangCodePages)
1426 || IsEqualGUID(riid, &IID_IMLangFontLink))
1427 {
1428 MLang_AddRef(This);
1429 TRACE("Returning IID_IMLangFontLink %p ref = %d\n", This, This->ref);
1430 *ppvObject = &(This->vtbl_IMLangFontLink);
1431 return S_OK;
1432 }
1433
1434 if (IsEqualGUID(riid, &IID_IMLangFontLink2))
1435 {
1436 MLang_AddRef(This);
1437 TRACE("Returning IID_IMLangFontLink2 %p ref = %d\n", This, This->ref);
1438 *ppvObject = &(This->vtbl_IMLangFontLink2);
1439 return S_OK;
1440 }
1441
1442 if (IsEqualGUID(riid, &IID_IMultiLanguage) )
1443 {
1444 MLang_AddRef(This);
1445 TRACE("Returning IID_IMultiLanguage %p ref = %d\n", This, This->ref);
1446 *ppvObject = &(This->vtbl_IMultiLanguage);
1447 return S_OK;
1448 }
1449
1450 if (IsEqualGUID(riid, &IID_IMultiLanguage2) )
1451 {
1452 MLang_AddRef(This);
1453 *ppvObject = &(This->vtbl_IMultiLanguage3);
1454 TRACE("Returning IID_IMultiLanguage2 %p ref = %d\n", This, This->ref);
1455 return S_OK;
1456 }
1457
1458 if (IsEqualGUID(riid, &IID_IMultiLanguage3) )
1459 {
1460 MLang_AddRef(This);
1461 *ppvObject = &(This->vtbl_IMultiLanguage3);
1462 TRACE("Returning IID_IMultiLanguage3 %p ref = %d\n", This, This->ref);
1463 return S_OK;
1464 }
1465
1466 if (IsEqualGUID(riid, &IID_IMLangLineBreakConsole))
1467 {
1468 MLang_AddRef(This);
1469 TRACE("Returning IID_IMLangLineBreakConsole %p ref = %d\n", This, This->ref);
1470 *ppvObject = &(This->vtbl_IMLangLineBreakConsole);
1471 return S_OK;
1472 }
1473
1474
1475 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1476 return E_NOINTERFACE;
1477 }
1478
1479 /******************************************************************************/
1480
1481 typedef struct tagEnumCodePage_impl
1482 {
1483 const IEnumCodePageVtbl *vtbl_IEnumCodePage;
1484 LONG ref;
1485 MIMECPINFO *cpinfo;
1486 DWORD total, pos;
1487 } EnumCodePage_impl;
1488
1489 static HRESULT WINAPI fnIEnumCodePage_QueryInterface(
1490 IEnumCodePage* iface,
1491 REFIID riid,
1492 void** ppvObject)
1493 {
1494 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1495
1496 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1497
1498 if (IsEqualGUID(riid, &IID_IUnknown)
1499 || IsEqualGUID(riid, &IID_IEnumCodePage))
1500 {
1501 IEnumCodePage_AddRef(iface);
1502 TRACE("Returning IID_IEnumCodePage %p ref = %d\n", This, This->ref);
1503 *ppvObject = &(This->vtbl_IEnumCodePage);
1504 return S_OK;
1505 }
1506
1507 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1508 return E_NOINTERFACE;
1509 }
1510
1511 static ULONG WINAPI fnIEnumCodePage_AddRef(
1512 IEnumCodePage* iface)
1513 {
1514 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1515 return InterlockedIncrement(&This->ref);
1516 }
1517
1518 static ULONG WINAPI fnIEnumCodePage_Release(
1519 IEnumCodePage* iface)
1520 {
1521 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1522 ULONG ref = InterlockedDecrement(&This->ref);
1523
1524 TRACE("%p ref = %d\n", This, ref);
1525 if (ref == 0)
1526 {
1527 TRACE("Destroying %p\n", This);
1528 HeapFree(GetProcessHeap(), 0, This->cpinfo);
1529 HeapFree(GetProcessHeap(), 0, This);
1530 }
1531
1532 return ref;
1533 }
1534
1535 static HRESULT WINAPI fnIEnumCodePage_Clone(
1536 IEnumCodePage* iface,
1537 IEnumCodePage** ppEnum)
1538 {
1539 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1540 FIXME("%p %p\n", This, ppEnum);
1541 return E_NOTIMPL;
1542 }
1543
1544 static HRESULT WINAPI fnIEnumCodePage_Next(
1545 IEnumCodePage* iface,
1546 ULONG celt,
1547 PMIMECPINFO rgelt,
1548 ULONG* pceltFetched)
1549 {
1550 ULONG i;
1551
1552 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1553 TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
1554
1555 if (!pceltFetched) return S_FALSE;
1556 *pceltFetched = 0;
1557
1558 if (!rgelt) return S_FALSE;
1559
1560 if (This->pos + celt > This->total)
1561 celt = This->total - This->pos;
1562
1563 if (!celt) return S_FALSE;
1564
1565 memcpy(rgelt, This->cpinfo + This->pos, celt * sizeof(MIMECPINFO));
1566 *pceltFetched = celt;
1567 This->pos += celt;
1568
1569 for (i = 0; i < celt; i++)
1570 {
1571 TRACE("#%u: %08x %u %u %s %s %s %s %s %s %d\n",
1572 i, rgelt[i].dwFlags, rgelt[i].uiCodePage,
1573 rgelt[i].uiFamilyCodePage,
1574 wine_dbgstr_w(rgelt[i].wszDescription),
1575 wine_dbgstr_w(rgelt[i].wszWebCharset),
1576 wine_dbgstr_w(rgelt[i].wszHeaderCharset),
1577 wine_dbgstr_w(rgelt[i].wszBodyCharset),
1578 wine_dbgstr_w(rgelt[i].wszFixedWidthFont),
1579 wine_dbgstr_w(rgelt[i].wszProportionalFont),
1580 rgelt[i].bGDICharset);
1581 }
1582 return S_OK;
1583 }
1584
1585 static HRESULT WINAPI fnIEnumCodePage_Reset(
1586 IEnumCodePage* iface)
1587 {
1588 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1589 TRACE("%p\n", This);
1590
1591 This->pos = 0;
1592 return S_OK;
1593 }
1594
1595 static HRESULT WINAPI fnIEnumCodePage_Skip(
1596 IEnumCodePage* iface,
1597 ULONG celt)
1598 {
1599 ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
1600 TRACE("%p %u\n", This, celt);
1601
1602 if (celt >= This->total) return S_FALSE;
1603
1604 This->pos += celt;
1605 return S_OK;
1606 }
1607
1608 static const IEnumCodePageVtbl IEnumCodePage_vtbl =
1609 {
1610 fnIEnumCodePage_QueryInterface,
1611 fnIEnumCodePage_AddRef,
1612 fnIEnumCodePage_Release,
1613 fnIEnumCodePage_Clone,
1614 fnIEnumCodePage_Next,
1615 fnIEnumCodePage_Reset,
1616 fnIEnumCodePage_Skip
1617 };
1618
1619 static HRESULT EnumCodePage_create( MLang_impl* mlang, DWORD grfFlags,
1620 LANGID LangId, IEnumCodePage** ppEnumCodePage )
1621 {
1622 EnumCodePage_impl *ecp;
1623 MIMECPINFO *cpinfo;
1624 UINT i, n;
1625
1626 TRACE("%p, %08x, %04x, %p\n", mlang, grfFlags, LangId, ppEnumCodePage);
1627
1628 if (!grfFlags) /* enumerate internal data base of encodings */
1629 grfFlags = MIMECONTF_MIME_LATEST;
1630
1631 ecp = HeapAlloc( GetProcessHeap(), 0, sizeof (EnumCodePage_impl) );
1632 ecp->vtbl_IEnumCodePage = &IEnumCodePage_vtbl;
1633 ecp->ref = 1;
1634 ecp->pos = 0;
1635 ecp->total = 0;
1636 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1637 {
1638 for (n = 0; n < mlang_data[i].number_of_cp; n++)
1639 {
1640 if (mlang_data[i].mime_cp_info[n].flags & grfFlags)
1641 ecp->total++;
1642 }
1643 }
1644
1645 ecp->cpinfo = HeapAlloc(GetProcessHeap(), 0,
1646 sizeof(MIMECPINFO) * ecp->total);
1647 cpinfo = ecp->cpinfo;
1648
1649 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1650 {
1651 for (n = 0; n < mlang_data[i].number_of_cp; n++)
1652 {
1653 if (mlang_data[i].mime_cp_info[n].flags & grfFlags)
1654 fill_cp_info(&mlang_data[i], n, cpinfo++);
1655 }
1656 }
1657
1658 TRACE("enumerated %d codepages with flags %08x\n", ecp->total, grfFlags);
1659
1660 *ppEnumCodePage = (IEnumCodePage*) ecp;
1661
1662 return S_OK;
1663 }
1664
1665 /******************************************************************************/
1666
1667 typedef struct tagEnumScript_impl
1668 {
1669 const IEnumScriptVtbl *vtbl_IEnumScript;
1670 LONG ref;
1671 SCRIPTINFO *script_info;
1672 DWORD total, pos;
1673 } EnumScript_impl;
1674
1675 static HRESULT WINAPI fnIEnumScript_QueryInterface(
1676 IEnumScript* iface,
1677 REFIID riid,
1678 void** ppvObject)
1679 {
1680 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1681
1682 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1683
1684 if (IsEqualGUID(riid, &IID_IUnknown)
1685 || IsEqualGUID(riid, &IID_IEnumScript))
1686 {
1687 IEnumScript_AddRef(iface);
1688 TRACE("Returning IID_IEnumScript %p ref = %d\n", This, This->ref);
1689 *ppvObject = &(This->vtbl_IEnumScript);
1690 return S_OK;
1691 }
1692
1693 WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1694 return E_NOINTERFACE;
1695 }
1696
1697 static ULONG WINAPI fnIEnumScript_AddRef(
1698 IEnumScript* iface)
1699 {
1700 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1701 return InterlockedIncrement(&This->ref);
1702 }
1703
1704 static ULONG WINAPI fnIEnumScript_Release(
1705 IEnumScript* iface)
1706 {
1707 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1708 ULONG ref = InterlockedDecrement(&This->ref);
1709
1710 TRACE("%p ref = %d\n", This, ref);
1711 if (ref == 0)
1712 {
1713 TRACE("Destroying %p\n", This);
1714 HeapFree(GetProcessHeap(), 0, This->script_info);
1715 HeapFree(GetProcessHeap(), 0, This);
1716 }
1717
1718 return ref;
1719 }
1720
1721 static HRESULT WINAPI fnIEnumScript_Clone(
1722 IEnumScript* iface,
1723 IEnumScript** ppEnum)
1724 {
1725 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1726 FIXME("%p %p: stub!\n", This, ppEnum);
1727 return E_NOTIMPL;
1728 }
1729
1730 static HRESULT WINAPI fnIEnumScript_Next(
1731 IEnumScript* iface,
1732 ULONG celt,
1733 PSCRIPTINFO rgelt,
1734 ULONG* pceltFetched)
1735 {
1736 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1737 TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
1738
1739 if (!pceltFetched || !rgelt) return E_FAIL;
1740
1741 *pceltFetched = 0;
1742
1743 if (This->pos + celt > This->total)
1744 celt = This->total - This->pos;
1745
1746 if (!celt) return S_FALSE;
1747
1748 memcpy(rgelt, This->script_info + This->pos, celt * sizeof(SCRIPTINFO));
1749 *pceltFetched = celt;
1750 This->pos += celt;
1751
1752 return S_OK;
1753 }
1754
1755 static HRESULT WINAPI fnIEnumScript_Reset(
1756 IEnumScript* iface)
1757 {
1758 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1759 TRACE("%p\n", This);
1760
1761 This->pos = 0;
1762 return S_OK;
1763 }
1764
1765 static HRESULT WINAPI fnIEnumScript_Skip(
1766 IEnumScript* iface,
1767 ULONG celt)
1768 {
1769 ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1770 TRACE("%p %u\n", This, celt);
1771
1772 if (celt >= This->total) return S_FALSE;
1773
1774 This->pos += celt;
1775 return S_OK;
1776 }
1777
1778 static const IEnumScriptVtbl IEnumScript_vtbl =
1779 {
1780 fnIEnumScript_QueryInterface,
1781 fnIEnumScript_AddRef,
1782 fnIEnumScript_Release,
1783 fnIEnumScript_Clone,
1784 fnIEnumScript_Next,
1785 fnIEnumScript_Reset,
1786 fnIEnumScript_Skip
1787 };
1788
1789 static HRESULT EnumScript_create( MLang_impl* mlang, DWORD dwFlags,
1790 LANGID LangId, IEnumScript** ppEnumScript )
1791 {
1792 EnumScript_impl *es;
1793 UINT i;
1794
1795 TRACE("%p, %08x, %04x, %p: stub!\n", mlang, dwFlags, LangId, ppEnumScript);
1796
1797 if (!dwFlags) /* enumerate all available scripts */
1798 dwFlags = SCRIPTCONTF_SCRIPT_USER | SCRIPTCONTF_SCRIPT_HIDE | SCRIPTCONTF_SCRIPT_SYSTEM;
1799
1800 es = HeapAlloc( GetProcessHeap(), 0, sizeof (EnumScript_impl) );
1801 es->vtbl_IEnumScript = &IEnumScript_vtbl;
1802 es->ref = 1;
1803 es->pos = 0;
1804 /* do not enumerate unicode flavours */
1805 es->total = sizeof(mlang_data)/sizeof(mlang_data[0]) - 1;
1806 es->script_info = HeapAlloc(GetProcessHeap(), 0, sizeof(SCRIPTINFO) * es->total);
1807
1808 for (i = 0; i < es->total; i++)
1809 {
1810 es->script_info[i].ScriptId = i;
1811 es->script_info[i].uiCodePage = mlang_data[i].family_codepage;
1812 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].description, -1,
1813 es->script_info[i].wszDescription, MAX_SCRIPT_NAME);
1814 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].fixed_font, -1,
1815 es->script_info[i].wszFixedWidthFont, MAX_MIMEFACE_NAME);
1816 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].proportional_font, -1,
1817 es->script_info[i].wszProportionalFont, MAX_MIMEFACE_NAME);
1818 }
1819
1820 TRACE("enumerated %d scripts with flags %08x\n", es->total, dwFlags);
1821
1822 *ppEnumScript = (IEnumScript *)es;
1823
1824 return S_OK;
1825 }
1826
1827 /******************************************************************************/
1828
1829 static HRESULT WINAPI fnIMLangFontLink_QueryInterface(
1830 IMLangFontLink* iface,
1831 REFIID riid,
1832 void** ppvObject)
1833 {
1834 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1835 return MLang_QueryInterface( This, riid, ppvObject );
1836 }
1837
1838 static ULONG WINAPI fnIMLangFontLink_AddRef(
1839 IMLangFontLink* iface)
1840 {
1841 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1842 return MLang_AddRef( This );
1843 }
1844
1845 static ULONG WINAPI fnIMLangFontLink_Release(
1846 IMLangFontLink* iface)
1847 {
1848 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1849 return MLang_Release( This );
1850 }
1851
1852 static HRESULT WINAPI fnIMLangFontLink_GetCharCodePages(
1853 IMLangFontLink* iface,
1854 WCHAR chSrc,
1855 DWORD* pdwCodePages)
1856 {
1857 int i;
1858 CHAR buf;
1859 BOOL used_dc;
1860 DWORD codePages;
1861
1862 *pdwCodePages = 0;
1863
1864 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1865 {
1866 WideCharToMultiByte(mlang_data[i].family_codepage, WC_NO_BEST_FIT_CHARS,
1867 &chSrc, 1, &buf, 1, NULL, &used_dc);
1868
1869 /* If default char is not used, current codepage include the given symbol */
1870 if (!used_dc)
1871 {
1872 IMLangFontLink_CodePageToCodePages(iface,
1873 mlang_data[i].family_codepage, &codePages);
1874 *pdwCodePages |= codePages;
1875 }
1876 }
1877 return S_OK;
1878 }
1879
1880 static HRESULT WINAPI fnIMLangFontLink_GetStrCodePages(
1881 IMLangFontLink* iface,
1882 const WCHAR* pszSrc,
1883 long cchSrc,
1884 DWORD dwPriorityCodePages,
1885 DWORD* pdwCodePages,
1886 long* pcchCodePages)
1887 {
1888 FIXME("(pszSrc=%s, cchSrc=%ld, dwPriorityCodePages=%d) stub\n", debugstr_w(pszSrc), cchSrc, dwPriorityCodePages);
1889 *pdwCodePages = 0;
1890 *pcchCodePages = 1;
1891 return S_OK;
1892 }
1893
1894 static HRESULT WINAPI fnIMLangFontLink_CodePageToCodePages(
1895 IMLangFontLink* iface,
1896 UINT uCodePage,
1897 DWORD* pdwCodePages)
1898 {
1899 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1900 CHARSETINFO cs;
1901 BOOL rc;
1902
1903 TRACE("(%p) Seeking %u\n",This, uCodePage);
1904
1905 rc = TranslateCharsetInfo((DWORD*)uCodePage, &cs, TCI_SRCCODEPAGE);
1906
1907 if (rc)
1908 {
1909 *pdwCodePages = cs.fs.fsCsb[0];
1910 TRACE("resulting CodePages 0x%x\n",*pdwCodePages);
1911 return S_OK;
1912 }
1913
1914 TRACE("CodePage Not Found\n");
1915 *pdwCodePages = 0;
1916 return E_FAIL;
1917 }
1918
1919 static HRESULT WINAPI fnIMLangFontLink_CodePagesToCodePage(
1920 IMLangFontLink* iface,
1921 DWORD dwCodePages,
1922 UINT uDefaultCodePage,
1923 UINT* puCodePage)
1924 {
1925 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1926 DWORD mask = 0x00000000;
1927 UINT i;
1928 CHARSETINFO cs;
1929 BOOL rc;
1930
1931 TRACE("(%p) scanning 0x%x default page %u\n",This, dwCodePages,
1932 uDefaultCodePage);
1933
1934 *puCodePage = 0x00000000;
1935
1936 rc = TranslateCharsetInfo((DWORD*)uDefaultCodePage, &cs, TCI_SRCCODEPAGE);
1937
1938 if (rc && (dwCodePages & cs.fs.fsCsb[0]))
1939 {
1940 TRACE("Found Default Codepage\n");
1941 *puCodePage = uDefaultCodePage;
1942 return S_OK;
1943 }
1944
1945
1946 for (i = 0; i < 32; i++)
1947 {
1948
1949 mask = 1 << i;
1950 if (dwCodePages & mask)
1951 {
1952 DWORD Csb[2];
1953 Csb[0] = mask;
1954 Csb[1] = 0x0;
1955 rc = TranslateCharsetInfo(Csb, &cs, TCI_SRCFONTSIG);
1956 if (!rc)
1957 continue;
1958
1959 TRACE("Falling back to least significant found CodePage %u\n",
1960 cs.ciACP);
1961 *puCodePage = cs.ciACP;
1962 return S_OK;
1963 }
1964 }
1965
1966 TRACE("no codepage found\n");
1967 return E_FAIL;
1968 }
1969
1970 static HRESULT WINAPI fnIMLangFontLink_GetFontCodePages(
1971 IMLangFontLink* iface,
1972 HDC hDC,
1973 HFONT hFont,
1974 DWORD* pdwCodePages)
1975 {
1976 HFONT old_font;
1977 FONTSIGNATURE fontsig;
1978 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1979
1980 TRACE("(%p)\n",This);
1981
1982 old_font = SelectObject(hDC,hFont);
1983 GetTextCharsetInfo(hDC,&fontsig, 0);
1984 SelectObject(hDC,old_font);
1985
1986 *pdwCodePages = fontsig.fsCsb[0];
1987 TRACE("CodePages is 0x%x\n",fontsig.fsCsb[0]);
1988
1989 return S_OK;
1990 }
1991
1992 static HRESULT WINAPI fnIMLangFontLink_MapFont(
1993 IMLangFontLink* iface,
1994 HDC hDC,
1995 DWORD dwCodePages,
1996 HFONT hSrcFont,
1997 HFONT* phDestFont)
1998 {
1999 FIXME("\n");
2000 return E_NOTIMPL;
2001 }
2002
2003 static HRESULT WINAPI fnIMLangFontLink_ReleaseFont(
2004 IMLangFontLink* iface,
2005 HFONT hFont)
2006 {
2007 FIXME("\n");
2008 return E_NOTIMPL;
2009 }
2010
2011 static HRESULT WINAPI fnIMLangFontLink_ResetFontMapping(
2012 IMLangFontLink* iface)
2013 {
2014 FIXME("\n");
2015 return E_NOTIMPL;
2016 }
2017
2018
2019 static const IMLangFontLinkVtbl IMLangFontLink_vtbl =
2020 {
2021 fnIMLangFontLink_QueryInterface,
2022 fnIMLangFontLink_AddRef,
2023 fnIMLangFontLink_Release,
2024 fnIMLangFontLink_GetCharCodePages,
2025 fnIMLangFontLink_GetStrCodePages,
2026 fnIMLangFontLink_CodePageToCodePages,
2027 fnIMLangFontLink_CodePagesToCodePage,
2028 fnIMLangFontLink_GetFontCodePages,
2029 fnIMLangFontLink_MapFont,
2030 fnIMLangFontLink_ReleaseFont,
2031 fnIMLangFontLink_ResetFontMapping,
2032 };
2033
2034 /******************************************************************************/
2035
2036 static HRESULT WINAPI fnIMultiLanguage_QueryInterface(
2037 IMultiLanguage* iface,
2038 REFIID riid,
2039 void** ppvObject)
2040 {
2041 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
2042 return MLang_QueryInterface( This, riid, ppvObject );
2043 }
2044
2045 static ULONG WINAPI fnIMultiLanguage_AddRef( IMultiLanguage* iface )
2046 {
2047 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
2048 return IMLangFontLink_AddRef( ((IMLangFontLink*)This) );
2049 }
2050
2051 static ULONG WINAPI fnIMultiLanguage_Release( IMultiLanguage* iface )
2052 {
2053 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
2054 return IMLangFontLink_Release( ((IMLangFontLink*)This) );
2055 }
2056
2057 static HRESULT WINAPI fnIMultiLanguage_GetNumberOfCodePageInfo(
2058 IMultiLanguage* iface,
2059 UINT* pcCodePage)
2060 {
2061 FIXME("\n");
2062 return E_NOTIMPL;
2063 }
2064
2065 static HRESULT WINAPI fnIMultiLanguage_GetCodePageInfo(
2066 IMultiLanguage* iface,
2067 UINT uiCodePage,
2068 PMIMECPINFO pCodePageInfo)
2069 {
2070 UINT i, n;
2071
2072 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
2073 TRACE("%p, %u, %p\n", This, uiCodePage, pCodePageInfo);
2074
2075 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2076 {
2077 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2078 {
2079 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
2080 {
2081 fill_cp_info(&mlang_data[i], n, pCodePageInfo);
2082 return S_OK;
2083 }
2084 }
2085 }
2086
2087 return S_FALSE;
2088 }
2089
2090 static HRESULT WINAPI fnIMultiLanguage_GetFamilyCodePage(
2091 IMultiLanguage* iface,
2092 UINT uiCodePage,
2093 UINT* puiFamilyCodePage)
2094 {
2095 return GetFamilyCodePage(uiCodePage, puiFamilyCodePage);
2096 }
2097
2098 static HRESULT WINAPI fnIMultiLanguage_EnumCodePages(
2099 IMultiLanguage* iface,
2100 DWORD grfFlags,
2101 IEnumCodePage** ppEnumCodePage)
2102 {
2103 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
2104 TRACE("%p %08x %p\n", This, grfFlags, ppEnumCodePage);
2105
2106 return EnumCodePage_create( This, grfFlags, 0, ppEnumCodePage );
2107 }
2108
2109 static HRESULT WINAPI fnIMultiLanguage_GetCharsetInfo(
2110 IMultiLanguage* iface,
2111 BSTR Charset,
2112 PMIMECSETINFO pCharsetInfo)
2113 {
2114 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
2115 return IMultiLanguage3_GetCharsetInfo((IMultiLanguage3*)&This->vtbl_IMultiLanguage3, Charset, pCharsetInfo);
2116 }
2117
2118 static HRESULT WINAPI fnIMultiLanguage_IsConvertible(
2119 IMultiLanguage* iface,
2120 DWORD dwSrcEncoding,
2121 DWORD dwDstEncoding)
2122 {
2123 return IsConvertINetStringAvailable(dwSrcEncoding, dwDstEncoding);
2124 }
2125
2126 static HRESULT WINAPI fnIMultiLanguage_ConvertString(
2127 IMultiLanguage* iface,
2128 DWORD* pdwMode,
2129 DWORD dwSrcEncoding,
2130 DWORD dwDstEncoding,
2131 BYTE* pSrcStr,
2132 UINT* pcSrcSize,
2133 BYTE* pDstStr,
2134 UINT* pcDstSize)
2135 {
2136 return ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding,
2137 (LPCSTR)pSrcStr, (LPINT)pcSrcSize, (LPSTR)pDstStr, (LPINT)pcDstSize);
2138 }
2139
2140 static HRESULT WINAPI fnIMultiLanguage_ConvertStringToUnicode(
2141 IMultiLanguage* iface,
2142 DWORD* pdwMode,
2143 DWORD dwEncoding,
2144 CHAR* pSrcStr,
2145 UINT* pcSrcSize,
2146 WCHAR* pDstStr,
2147 UINT* pcDstSize)
2148 {
2149 return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
2150 (LPCSTR)pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2151 }
2152
2153 static HRESULT WINAPI fnIMultiLanguage_ConvertStringFromUnicode(
2154 IMultiLanguage* iface,
2155 DWORD* pdwMode,
2156 DWORD dwEncoding,
2157 WCHAR* pSrcStr,
2158 UINT* pcSrcSize,
2159 CHAR* pDstStr,
2160 UINT* pcDstSize)
2161 {
2162 return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
2163 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2164 }
2165
2166 static HRESULT WINAPI fnIMultiLanguage_ConvertStringReset(
2167 IMultiLanguage* iface)
2168 {
2169 FIXME("\n");
2170 return E_NOTIMPL;
2171 }
2172
2173 static HRESULT WINAPI fnIMultiLanguage_GetRfc1766FromLcid(
2174 IMultiLanguage* iface,
2175 LCID lcid,
2176 BSTR* pbstrRfc1766)
2177 {
2178 WCHAR buf[MAX_RFC1766_NAME];
2179
2180 TRACE("%p %04x %p\n", iface, lcid, pbstrRfc1766);
2181
2182 if (lcid_to_rfc1766W( lcid, buf, MAX_RFC1766_NAME ))
2183 {
2184 *pbstrRfc1766 = SysAllocString( buf );
2185 return S_OK;
2186 }
2187 return E_FAIL;
2188 }
2189
2190 static HRESULT WINAPI fnIMultiLanguage_GetLcidFromRfc1766(
2191 IMultiLanguage* iface,
2192 LCID* pLocale,
2193 BSTR bstrRfc1766)
2194 {
2195 HRESULT hr;
2196 IEnumRfc1766 *rfc1766;
2197
2198 TRACE("%p %p %s\n", iface, pLocale, debugstr_w(bstrRfc1766));
2199
2200 if (!pLocale || !bstrRfc1766)
2201 return E_INVALIDARG;
2202
2203 hr = IMultiLanguage_EnumRfc1766(iface, &rfc1766);
2204 if (FAILED(hr))
2205 return hr;
2206
2207 hr = lcid_from_rfc1766(rfc1766, pLocale, bstrRfc1766);
2208
2209 IEnumRfc1766_Release(rfc1766);
2210 return hr;
2211 }
2212
2213 /******************************************************************************/
2214
2215 typedef struct tagEnumRfc1766_impl
2216 {
2217 const IEnumRfc1766Vtbl *vtbl_IEnumRfc1766;
2218 LONG ref;
2219 RFC1766INFO *info;
2220 DWORD total, pos;
2221 } EnumRfc1766_impl;
2222
2223 static HRESULT WINAPI fnIEnumRfc1766_QueryInterface(
2224 IEnumRfc1766 *iface,
2225 REFIID riid,
2226 void** ppvObject)
2227 {
2228 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
2229
2230 TRACE("%p -> %s\n", This, debugstr_guid(riid) );
2231
2232 if (IsEqualGUID(riid, &IID_IUnknown)
2233 || IsEqualGUID(riid, &IID_IEnumRfc1766))
2234 {
2235 IEnumRfc1766_AddRef(iface);
2236 TRACE("Returning IID_IEnumRfc1766 %p ref = %d\n", This, This->ref);
2237 *ppvObject = &(This->vtbl_IEnumRfc1766);
2238 return S_OK;
2239 }
2240
2241 WARN("(%p) -> (%s,%p), not found\n",This,debugstr_guid(riid),ppvObject);
2242 return E_NOINTERFACE;
2243 }
2244
2245 static ULONG WINAPI fnIEnumRfc1766_AddRef(
2246 IEnumRfc1766 *iface)
2247 {
2248 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
2249 return InterlockedIncrement(&This->ref);
2250 }
2251
2252 static ULONG WINAPI fnIEnumRfc1766_Release(
2253 IEnumRfc1766 *iface)
2254 {
2255 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
2256 ULONG ref = InterlockedDecrement(&This->ref);
2257
2258 TRACE("%p ref = %d\n", This, ref);
2259 if (ref == 0)
2260 {
2261 TRACE("Destroying %p\n", This);
2262 HeapFree(GetProcessHeap(), 0, This->info);
2263 HeapFree(GetProcessHeap(), 0, This);
2264 }
2265 return ref;
2266 }
2267
2268 static HRESULT WINAPI fnIEnumRfc1766_Clone(
2269 IEnumRfc1766 *iface,
2270 IEnumRfc1766 **ppEnum)
2271 {
2272 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
2273 FIXME("%p %p\n", This, ppEnum);
2274 return E_NOTIMPL;
2275 }
2276
2277 static HRESULT WINAPI fnIEnumRfc1766_Next(
2278 IEnumRfc1766 *iface,
2279 ULONG celt,
2280 PRFC1766INFO rgelt,
2281 ULONG *pceltFetched)
2282 {
2283 ULONG i;
2284
2285 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
2286 TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
2287
2288 if (!pceltFetched) return S_FALSE;
2289 *pceltFetched = 0;
2290
2291 if (!rgelt) return S_FALSE;
2292
2293 if (This->pos + celt > This->total)
2294 celt = This->total - This->pos;
2295
2296 if (!celt) return S_FALSE;
2297
2298 memcpy(rgelt, This->info + This->pos, celt * sizeof(RFC1766INFO));
2299 *pceltFetched = celt;
2300 This->pos += celt;
2301
2302 for (i = 0; i < celt; i++)
2303 {
2304 TRACE("#%u: %08x %s %s\n",
2305 i, rgelt[i].lcid,
2306 wine_dbgstr_w(rgelt[i].wszRfc1766),
2307 wine_dbgstr_w(rgelt[i].wszLocaleName));
2308 }
2309 return S_OK;
2310 }
2311
2312 static HRESULT WINAPI fnIEnumRfc1766_Reset(
2313 IEnumRfc1766 *iface)
2314 {
2315 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
2316 TRACE("%p\n", This);
2317
2318 This->pos = 0;
2319 return S_OK;
2320 }
2321
2322 static HRESULT WINAPI fnIEnumRfc1766_Skip(
2323 IEnumRfc1766 *iface,
2324 ULONG celt)
2325 {
2326 ICOM_THIS_MULTI(EnumRfc1766_impl, vtbl_IEnumRfc1766, iface);
2327 TRACE("%p %u\n", This, celt);
2328
2329 if (celt >= This->total) return S_FALSE;
2330
2331 This->pos += celt;
2332 return S_OK;
2333 }
2334
2335 static const IEnumRfc1766Vtbl IEnumRfc1766_vtbl =
2336 {
2337 fnIEnumRfc1766_QueryInterface,
2338 fnIEnumRfc1766_AddRef,
2339 fnIEnumRfc1766_Release,
2340 fnIEnumRfc1766_Clone,
2341 fnIEnumRfc1766_Next,
2342 fnIEnumRfc1766_Reset,
2343 fnIEnumRfc1766_Skip
2344 };
2345
2346 struct enum_locales_data
2347 {
2348 RFC1766INFO *info;
2349 DWORD total, allocated;
2350 };
2351
2352 static BOOL CALLBACK enum_locales_proc(LPWSTR locale)
2353 {
2354 WCHAR *end;
2355 struct enum_locales_data *data = TlsGetValue(MLANG_tls_index);
2356 RFC1766INFO *info;
2357
2358 TRACE("%s\n", debugstr_w(locale));
2359
2360 if (data->total >= data->allocated)
2361 {
2362 data->allocated += 32;
2363 data->info = HeapReAlloc(GetProcessHeap(), 0, data->info, data->allocated * sizeof(RFC1766INFO));
2364 if (!data->info) return FALSE;
2365 }
2366
2367 info = &data->info[data->total];
2368
2369 info->lcid = strtolW(locale, &end, 16);
2370 if (*end) /* invalid number */
2371 return FALSE;
2372
2373 info->wszRfc1766[0] = 0;
2374 lcid_to_rfc1766W( info->lcid, info->wszRfc1766, MAX_RFC1766_NAME );
2375
2376 info->wszLocaleName[0] = 0;
2377 GetLocaleInfoW(info->lcid, LOCALE_SLANGUAGE, info->wszLocaleName, MAX_LOCALE_NAME);
2378 TRACE("ISO639: %s SLANGUAGE: %s\n", wine_dbgstr_w(info->wszRfc1766), wine_dbgstr_w(info->wszLocaleName));
2379
2380 data->total++;
2381
2382 return TRUE;
2383 }
2384
2385 static HRESULT EnumRfc1766_create(LANGID LangId, IEnumRfc1766 **ppEnum)
2386 {
2387 EnumRfc1766_impl *rfc;
2388 struct enum_locales_data data;
2389
2390 TRACE("%04x, %p\n", LangId, ppEnum);
2391
2392 rfc = HeapAlloc( GetProcessHeap(), 0, sizeof(EnumRfc1766_impl) );
2393 rfc->vtbl_IEnumRfc1766 = &IEnumRfc1766_vtbl;
2394 rfc->ref = 1;
2395 rfc->pos = 0;
2396 rfc->total = 0;
2397
2398 data.total = 0;
2399 data.allocated = 32;
2400 data.info = HeapAlloc(GetProcessHeap(), 0, data.allocated * sizeof(RFC1766INFO));
2401 if (!data.info)
2402 {
2403 HeapFree(GetProcessHeap(), 0, rfc);
2404 return S_FALSE;
2405 }
2406
2407 TlsSetValue(MLANG_tls_index, &data);
2408 EnumSystemLocalesW(enum_locales_proc, 0/*LOCALE_SUPPORTED*/);
2409 TlsSetValue(MLANG_tls_index, NULL);
2410
2411 TRACE("enumerated %d rfc1766 structures\n", data.total);
2412
2413 if (!data.total)
2414 {
2415 HeapFree(GetProcessHeap(), 0, data.info);
2416 HeapFree(GetProcessHeap(), 0, rfc);
2417 return FALSE;
2418 }
2419
2420 rfc->info = data.info;
2421 rfc->total = data.total;
2422
2423 *ppEnum = (IEnumRfc1766 *)rfc;
2424 return S_OK;
2425 }
2426
2427 static HRESULT WINAPI fnIMultiLanguage_EnumRfc1766(
2428 IMultiLanguage *iface,
2429 IEnumRfc1766 **ppEnumRfc1766)
2430 {
2431 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
2432 TRACE("%p %p\n", This, ppEnumRfc1766);
2433
2434 return EnumRfc1766_create(0, ppEnumRfc1766);
2435 }
2436
2437 /******************************************************************************/
2438
2439 static HRESULT WINAPI fnIMultiLanguage_GetRfc1766Info(
2440 IMultiLanguage* iface,
2441 LCID Locale,
2442 PRFC1766INFO pRfc1766Info)
2443 {
2444 FIXME("\n");
2445 return E_NOTIMPL;
2446 }
2447
2448 static HRESULT WINAPI fnIMultiLanguage_CreateConvertCharset(
2449 IMultiLanguage* iface,
2450 UINT uiSrcCodePage,
2451 UINT uiDstCodePage,
2452 DWORD dwProperty,
2453 IMLangConvertCharset** ppMLangConvertCharset)
2454 {
2455 FIXME("\n");
2456 return E_NOTIMPL;
2457 }
2458
2459 static const IMultiLanguageVtbl IMultiLanguage_vtbl =
2460 {
2461 fnIMultiLanguage_QueryInterface,
2462 fnIMultiLanguage_AddRef,
2463 fnIMultiLanguage_Release,
2464 fnIMultiLanguage_GetNumberOfCodePageInfo,
2465 fnIMultiLanguage_GetCodePageInfo,
2466 fnIMultiLanguage_GetFamilyCodePage,
2467 fnIMultiLanguage_EnumCodePages,
2468 fnIMultiLanguage_GetCharsetInfo,
2469 fnIMultiLanguage_IsConvertible,
2470 fnIMultiLanguage_ConvertString,
2471 fnIMultiLanguage_ConvertStringToUnicode,
2472 fnIMultiLanguage_ConvertStringFromUnicode,
2473 fnIMultiLanguage_ConvertStringReset,
2474 fnIMultiLanguage_GetRfc1766FromLcid,
2475 fnIMultiLanguage_GetLcidFromRfc1766,
2476 fnIMultiLanguage_EnumRfc1766,
2477 fnIMultiLanguage_GetRfc1766Info,
2478 fnIMultiLanguage_CreateConvertCharset,
2479 };
2480
2481
2482 /******************************************************************************/
2483
2484 static HRESULT WINAPI fnIMultiLanguage2_QueryInterface(
2485 IMultiLanguage3* iface,
2486 REFIID riid,
2487 void** ppvObject)
2488 {
2489 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2490 return MLang_QueryInterface( This, riid, ppvObject );
2491 }
2492
2493 static ULONG WINAPI fnIMultiLanguage2_AddRef( IMultiLanguage3* iface )
2494 {
2495 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2496 return MLang_AddRef( This );
2497 }
2498
2499 static ULONG WINAPI fnIMultiLanguage2_Release( IMultiLanguage3* iface )
2500 {
2501 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2502 return MLang_Release( This );
2503 }
2504
2505 static HRESULT WINAPI fnIMultiLanguage2_GetNumberOfCodePageInfo(
2506 IMultiLanguage3* iface,
2507 UINT* pcCodePage)
2508 {
2509 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2510 TRACE("%p, %p\n", This, pcCodePage);
2511
2512 if (!pcCodePage) return S_FALSE;
2513
2514 *pcCodePage = This->total_cp;
2515 return S_OK;
2516 }
2517
2518 static void fill_cp_info(const struct mlang_data *ml_data, UINT index, MIMECPINFO *mime_cp_info)
2519 {
2520 CHARSETINFO csi;
2521
2522 if (TranslateCharsetInfo((DWORD *)ml_data->family_codepage, &csi, TCI_SRCCODEPAGE))
2523 mime_cp_info->bGDICharset = csi.ciCharset;
2524 else
2525 mime_cp_info->bGDICharset = DEFAULT_CHARSET;
2526
2527 mime_cp_info->dwFlags = ml_data->mime_cp_info[index].flags;
2528 mime_cp_info->uiCodePage = ml_data->mime_cp_info[index].cp;
2529 mime_cp_info->uiFamilyCodePage = ml_data->family_codepage;
2530 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].description, -1,
2531 mime_cp_info->wszDescription, sizeof(mime_cp_info->wszDescription)/sizeof(WCHAR));
2532 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].web_charset, -1,
2533 mime_cp_info->wszWebCharset, sizeof(mime_cp_info->wszWebCharset)/sizeof(WCHAR));
2534 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].header_charset, -1,
2535 mime_cp_info->wszHeaderCharset, sizeof(mime_cp_info->wszHeaderCharset)/sizeof(WCHAR));
2536 MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].body_charset, -1,
2537 mime_cp_info->wszBodyCharset, sizeof(mime_cp_info->wszBodyCharset)/sizeof(WCHAR));
2538
2539 MultiByteToWideChar(CP_ACP, 0, ml_data->fixed_font, -1,
2540 mime_cp_info->wszFixedWidthFont, sizeof(mime_cp_info->wszFixedWidthFont)/sizeof(WCHAR));
2541 MultiByteToWideChar(CP_ACP, 0, ml_data->proportional_font, -1,
2542 mime_cp_info->wszProportionalFont, sizeof(mime_cp_info->wszProportionalFont)/sizeof(WCHAR));
2543
2544 TRACE("%08x %u %u %s %s %s %s %s %s %d\n",
2545 mime_cp_info->dwFlags, mime_cp_info->uiCodePage,
2546 mime_cp_info->uiFamilyCodePage,
2547 wine_dbgstr_w(mime_cp_info->wszDescription),
2548 wine_dbgstr_w(mime_cp_info->wszWebCharset),
2549 wine_dbgstr_w(mime_cp_info->wszHeaderCharset),
2550 wine_dbgstr_w(mime_cp_info->wszBodyCharset),
2551 wine_dbgstr_w(mime_cp_info->wszFixedWidthFont),
2552 wine_dbgstr_w(mime_cp_info->wszProportionalFont),
2553 mime_cp_info->bGDICharset);
2554 }
2555
2556 static HRESULT WINAPI fnIMultiLanguage2_GetCodePageInfo(
2557 IMultiLanguage3* iface,
2558 UINT uiCodePage,
2559 LANGID LangId,
2560 PMIMECPINFO pCodePageInfo)
2561 {
2562 UINT i, n;
2563
2564 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2565 TRACE("%p, %u, %04x, %p\n", This, uiCodePage, LangId, pCodePageInfo);
2566
2567 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2568 {
2569 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2570 {
2571 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
2572 {
2573 fill_cp_info(&mlang_data[i], n, pCodePageInfo);
2574 return S_OK;
2575 }
2576 }
2577 }
2578
2579 return S_FALSE;
2580 }
2581
2582 static HRESULT WINAPI fnIMultiLanguage2_GetFamilyCodePage(
2583 IMultiLanguage3* iface,
2584 UINT uiCodePage,
2585 UINT* puiFamilyCodePage)
2586 {
2587 return GetFamilyCodePage(uiCodePage, puiFamilyCodePage);
2588 }
2589
2590 static HRESULT WINAPI fnIMultiLanguage2_EnumCodePages(
2591 IMultiLanguage3* iface,
2592 DWORD grfFlags,
2593 LANGID LangId,
2594 IEnumCodePage** ppEnumCodePage)
2595 {
2596 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2597 TRACE("%p %08x %04x %p\n", This, grfFlags, LangId, ppEnumCodePage);
2598
2599 return EnumCodePage_create( This, grfFlags, LangId, ppEnumCodePage );
2600 }
2601
2602 static HRESULT WINAPI fnIMultiLanguage2_GetCharsetInfo(
2603 IMultiLanguage3* iface,
2604 BSTR Charset,
2605 PMIMECSETINFO pCharsetInfo)
2606 {
2607 UINT i, n;
2608
2609 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2610 TRACE("%p %s %p\n", This, debugstr_w(Charset), pCharsetInfo);
2611
2612 if (!pCharsetInfo) return E_FAIL;
2613
2614 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2615 {
2616 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2617 {
2618 WCHAR csetW[MAX_MIMECSET_NAME];
2619
2620 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].mime_cp_info[n].web_charset, -1, csetW, MAX_MIMECSET_NAME);
2621 if (!lstrcmpiW(Charset, csetW))
2622 {
2623 pCharsetInfo->uiCodePage = mlang_data[i].family_codepage;
2624 pCharsetInfo->uiInternetEncoding = mlang_data[i].mime_cp_info[n].cp;
2625 strcpyW(pCharsetInfo->wszCharset, csetW);
2626 return S_OK;
2627 }
2628 }
2629 }
2630
2631 /* FIXME:
2632 * Since we do not support charsets like iso-2022-jp and do not have
2633 * them in our database as a primary (web_charset) encoding this loop
2634 * does an attempt to 'approximate' charset name by header_charset.
2635 */
2636 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2637 {
2638 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2639 {
2640 WCHAR csetW[MAX_MIMECSET_NAME];
2641
2642 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].mime_cp_info[n].header_charset, -1, csetW, MAX_MIMECSET_NAME);
2643 if (!lstrcmpiW(Charset, csetW))
2644 {
2645 pCharsetInfo->uiCodePage = mlang_data[i].family_codepage;
2646 pCharsetInfo->uiInternetEncoding = mlang_data[i].mime_cp_info[n].cp;
2647 strcpyW(pCharsetInfo->wszCharset, csetW);
2648 return S_OK;
2649 }
2650 }
2651 }
2652
2653 return E_FAIL;
2654 }
2655
2656 static HRESULT WINAPI fnIMultiLanguage2_IsConvertible(
2657 IMultiLanguage3* iface,
2658 DWORD dwSrcEncoding,
2659 DWORD dwDstEncoding)
2660 {
2661 return IsConvertINetStringAvailable(dwSrcEncoding, dwDstEncoding);
2662 }
2663
2664 static HRESULT WINAPI fnIMultiLanguage2_ConvertString(
2665 IMultiLanguage3* iface,
2666 DWORD* pdwMode,
2667 DWORD dwSrcEncoding,
2668 DWORD dwDstEncoding,
2669 BYTE* pSrcStr,
2670 UINT* pcSrcSize,
2671 BYTE* pDstStr,
2672 UINT* pcDstSize)
2673 {
2674 return ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding,
2675 (LPCSTR)pSrcStr, (LPINT)pcSrcSize, (LPSTR)pDstStr, (LPINT)pcDstSize);
2676 }
2677
2678 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicode(
2679 IMultiLanguage3* iface,
2680 DWORD* pdwMode,
2681 DWORD dwEncoding,
2682 CHAR* pSrcStr,
2683 UINT* pcSrcSize,
2684 WCHAR* pDstStr,
2685 UINT* pcDstSize)
2686 {
2687 return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
2688 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2689 }
2690
2691 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringFromUnicode(
2692 IMultiLanguage3* iface,
2693 DWORD* pdwMode,
2694 DWORD dwEncoding,
2695 WCHAR* pSrcStr,
2696 UINT* pcSrcSize,
2697 CHAR* pDstStr,
2698 UINT* pcDstSize)
2699 {
2700 return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
2701 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2702 }
2703
2704 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringReset(
2705 IMultiLanguage3* iface)
2706 {
2707 FIXME("\n");
2708 return E_NOTIMPL;
2709 }
2710
2711 static HRESULT WINAPI fnIMultiLanguage2_GetRfc1766FromLcid(
2712 IMultiLanguage3* iface,
2713 LCID lcid,
2714 BSTR* pbstrRfc1766)
2715 {
2716 WCHAR buf[MAX_RFC1766_NAME];
2717
2718 TRACE("%p %04x %p\n", iface, lcid, pbstrRfc1766);
2719
2720 if (lcid_to_rfc1766W( lcid, buf, MAX_RFC1766_NAME ))
2721 {
2722 *pbstrRfc1766 = SysAllocString( buf );
2723 return S_OK;
2724 }
2725 return E_FAIL;
2726 }
2727
2728 static HRESULT WINAPI fnIMultiLanguage2_GetLcidFromRfc1766(
2729 IMultiLanguage3* iface,
2730 LCID* pLocale,
2731 BSTR bstrRfc1766)
2732 {
2733 HRESULT hr;
2734 IEnumRfc1766 *rfc1766;
2735
2736 TRACE("%p %p %s\n", iface, pLocale, debugstr_w(bstrRfc1766));
2737
2738 if (!pLocale || !bstrRfc1766)
2739 return E_INVALIDARG;
2740
2741 hr = IMultiLanguage2_EnumRfc1766(iface, 0, &rfc1766);
2742 if (FAILED(hr))
2743 return hr;
2744
2745 hr = lcid_from_rfc1766(rfc1766, pLocale, bstrRfc1766);
2746
2747 IEnumRfc1766_Release(rfc1766);
2748 return hr;
2749 }
2750
2751 static HRESULT WINAPI fnIMultiLanguage2_EnumRfc1766(
2752 IMultiLanguage3* iface,
2753 LANGID LangId,
2754 IEnumRfc1766** ppEnumRfc1766)
2755 {
2756 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
2757 TRACE("%p %p\n", This, ppEnumRfc1766);
2758
2759 return EnumRfc1766_create(LangId, ppEnumRfc1766);
2760 }
2761
2762 static HRESULT WINAPI fnIMultiLanguage2_GetRfc1766Info(
2763 IMultiLanguage3* iface,
2764 LCID Locale,
2765 LANGID LangId,
2766 PRFC1766INFO pRfc1766Info)
2767 {
2768 FIXME("\n");
2769 return E_NOTIMPL;
2770 }
2771
2772 static HRESULT WINAPI fnIMultiLanguage2_CreateConvertCharset(
2773 IMultiLanguage3* iface,
2774 UINT uiSrcCodePage,
2775 UINT uiDstCodePage,
2776 DWORD dwProperty,
2777 IMLangConvertCharset** ppMLangConvertCharset)
2778 {
2779 FIXME("\n");
2780 return E_NOTIMPL;
2781 }
2782
2783 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringInIStream(
2784 IMultiLanguage3* iface,
2785 DWORD* pdwMode,
2786 DWORD dwFlag,
2787 WCHAR* lpFallBack,
2788 DWORD dwSrcEncoding,
2789 DWORD dwDstEncoding,
2790 IStream* pstmIn,
2791 IStream* pstmOut)
2792 {
2793 char *src, *dst = NULL;
2794 INT srclen, dstlen;
2795 STATSTG stat;
2796 HRESULT hr;
2797
2798 TRACE("%p %0x8 %s %u %u %p %p\n",
2799 pdwMode, dwFlag, debugstr_w(lpFallBack), dwSrcEncoding, dwDstEncoding, pstmIn, pstmOut);
2800
2801 FIXME("dwFlag and lpFallBack not handled\n");
2802
2803 hr = IStream_Stat(pstmIn, &stat, STATFLAG_NONAME);
2804 if (FAILED(hr)) return hr;
2805
2806 if (stat.cbSize.QuadPart > MAXLONG) return E_INVALIDARG;
2807 if (!(src = HeapAlloc(GetProcessHeap(), 0, stat.cbSize.QuadPart))) return E_OUTOFMEMORY;
2808
2809 hr = IStream_Read(pstmIn, src, stat.cbSize.QuadPart, (ULONG *)&srclen);
2810 if (FAILED(hr)) goto exit;
2811
2812 hr = ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding, src, &srclen, NULL, &dstlen);
2813 if (FAILED(hr)) goto exit;
2814
2815 if (!(dst = HeapAlloc(GetProcessHeap(), 0, dstlen)))
2816 {
2817 hr = E_OUTOFMEMORY;
2818 goto exit;
2819 }
2820 hr = ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding, src, &srclen, dst, &dstlen);
2821 if (FAILED(hr)) goto exit;
2822
2823 hr = IStream_Write(pstmOut, dst, dstlen, NULL);
2824
2825 exit:
2826 HeapFree(GetProcessHeap(), 0, src);
2827 HeapFree(GetProcessHeap(), 0, dst);
2828 return hr;
2829 }
2830
2831 /*
2832 * TODO: handle dwFlag and lpFallBack
2833 */
2834 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicodeEx(
2835 IMultiLanguage3* iface,
2836 DWORD* pdwMode,
2837 DWORD dwEncoding,
2838 CHAR* pSrcStr,
2839 UINT* pcSrcSize,
2840 WCHAR* pDstStr,
2841 UINT* pcDstSize,
2842 DWORD dwFlag,
2843 WCHAR* lpFallBack)
2844 {
2845 FIXME("\n");
2846 return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
2847 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2848 }
2849
2850 /*****************************************************************************
2851 * MultiLanguage2::ConvertStringToUnicodeEx
2852 *
2853 * Translates the multibyte string from the specified code page to Unicode.
2854 *
2855 * PARAMS
2856 * see ConvertStringToUnicode
2857 * dwFlag
2858 * lpFallBack if dwFlag contains MLCONVCHARF_USEDEFCHAR, lpFallBack string used
2859 * instead unconvertible characters.
2860 *
2861 * RETURNS
2862 * S_OK Success.
2863 * S_FALSE The conversion is not supported.
2864 * E_FAIL Some error has occurred.
2865 *
2866 * TODO: handle dwFlag and lpFallBack
2867 */
2868 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringFromUnicodeEx(
2869 IMultiLanguage3* This,
2870 DWORD* pdwMode,
2871 DWORD dwEncoding,
2872 WCHAR* pSrcStr,
2873 UINT* pcSrcSize,
2874 CHAR* pDstStr,
2875 UINT* pcDstSize,
2876 DWORD dwFlag,
2877 WCHAR* lpFallBack)
2878 {
2879 FIXME("\n");
2880 return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
2881 pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2882 }
2883
2884 static HRESULT WINAPI fnIMultiLanguage2_DetectCodepageInIStream(
2885 IMultiLanguage3* iface,
2886 DWORD dwFlag,
2887 DWORD dwPrefWinCodePage,
2888 IStream* pstmIn,
2889 DetectEncodingInfo* lpEncoding,
2890 INT* pnScores)
2891 {
2892 FIXME("\n");
2893 return E_NOTIMPL;
2894 }
2895
2896 static HRESULT WINAPI fnIMultiLanguage2_DetectInputCodepage(
2897 IMultiLanguage3* iface,
2898 DWORD dwFlag,
2899 DWORD dwPrefWinCodePage,
2900 CHAR* pSrcStr,
2901 INT* pcSrcSize,
2902 DetectEncodingInfo* lpEncoding,
2903 INT* pnScores)
2904 {
2905 FIXME("\n");
2906 return E_NOTIMPL;
2907 }
2908
2909 static HRESULT WINAPI fnIMultiLanguage2_ValidateCodePage(
2910 IMultiLanguage3* iface,
2911 UINT uiCodePage,
2912 HWND hwnd)
2913 {
2914 return IMultiLanguage2_ValidateCodePageEx(iface,uiCodePage,hwnd,0);
2915 }
2916
2917 static HRESULT WINAPI fnIMultiLanguage2_GetCodePageDescription(
2918 IMultiLanguage3* iface,
2919 UINT uiCodePage,
2920 LCID lcid,
2921 LPWSTR lpWideCharStr,
2922 int cchWideChar)
2923 {
2924 /* Find first instance */
2925 unsigned int i,n;
2926
2927 TRACE ("%u, %04x, %p, %d\n", uiCodePage, lcid, lpWideCharStr, cchWideChar);
2928 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2929 {
2930 for (n = 0; n < mlang_data[i].number_of_cp; n++)
2931 {
2932 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
2933 {
2934 MultiByteToWideChar(CP_ACP, 0,
2935 mlang_data[i].mime_cp_info[n].description,
2936 -1, lpWideCharStr, cchWideChar);
2937 return S_OK;
2938 }
2939 }
2940 }
2941
2942 return S_FALSE;
2943 }
2944
2945 static HRESULT WINAPI fnIMultiLanguage2_IsCodePageInstallable(
2946 IMultiLanguage3* iface,
2947 UINT uiCodePage)
2948 {
2949 FIXME("%u\n", uiCodePage);
2950 return E_NOTIMPL;
2951 }
2952
2953 static HRESULT WINAPI fnIMultiLanguage2_SetMimeDBSource(
2954 IMultiLanguage3* iface,
2955 MIMECONTF dwSource)
2956 {
2957 FIXME("0x%08x\n", dwSource);
2958 return S_OK;
2959 }
2960
2961 static HRESULT WINAPI fnIMultiLanguage2_GetNumberOfScripts(
2962 IMultiLanguage3* iface,
2963 UINT* pnScripts)
2964 {
2965 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2966 TRACE("%p %p\n", This, pnScripts);
2967
2968 if (!pnScripts) return S_FALSE;
2969
2970 *pnScripts = This->total_scripts;
2971 return S_OK;
2972 }
2973
2974 static HRESULT WINAPI fnIMultiLanguage2_EnumScripts(
2975 IMultiLanguage3* iface,
2976 DWORD dwFlags,
2977 LANGID LangId,
2978 IEnumScript** ppEnumScript)
2979 {
2980 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2981 TRACE("%p %08x %04x %p\n", This, dwFlags, LangId, ppEnumScript);
2982
2983 return EnumScript_create( This, dwFlags, LangId, ppEnumScript );
2984 }
2985
2986 static HRESULT WINAPI fnIMultiLanguage2_ValidateCodePageEx(
2987 IMultiLanguage3* iface,
2988 UINT uiCodePage,
2989 HWND hwnd,
2990 DWORD dwfIODControl)
2991 {
2992 int i;
2993 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
2994
2995 TRACE("%p %u %p %08x\n", This, uiCodePage, hwnd, dwfIODControl);
2996
2997 /* quick check for kernel32 supported code pages */
2998 if (IsValidCodePage(uiCodePage))
2999 return S_OK;
3000
3001 /* check for mlang supported code pages */
3002 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
3003 {
3004 int n;
3005 for (n = 0; n < mlang_data[i].number_of_cp; n++)
3006 {
3007 if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
3008 return S_OK;
3009 }
3010 }
3011
3012 if (dwfIODControl != CPIOD_PEEK)
3013 FIXME("Request to install codepage language pack not handled\n");
3014
3015 return S_FALSE;
3016 }
3017
3018 static HRESULT WINAPI fnIMultiLanguage3_DetectOutboundCodePage(
3019 IMultiLanguage3 *iface,
3020 DWORD dwFlags,
3021 LPCWSTR lpWideCharStr,
3022 UINT cchWideChar,
3023 UINT *puiPreferredCodePages,
3024 UINT nPreferredCodePages,
3025 UINT *puiDetectedCodePages,
3026 UINT *pnDetectedCodePages,
3027 WCHAR *lpSpecialChar)
3028 {
3029 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
3030 FIXME("(%p)->(%08x %s %u %p %u %p %p %p)\n", This, dwFlags, debugstr_w(lpWideCharStr),
3031 cchWideChar, puiPreferredCodePages, nPreferredCodePages, puiDetectedCodePages,
3032 pnDetectedCodePages, lpSpecialChar);
3033 return E_NOTIMPL;
3034 }
3035
3036 static HRESULT WINAPI fnIMultiLanguage3_DetectOutboundCodePageInIStream(
3037 IMultiLanguage3 *iface,
3038 DWORD dwFlags,
3039 IStream *pStrIn,
3040 UINT *puiPreferredCodePages,
3041 UINT nPreferredCodePages,
3042 UINT *puiDetectedCodePages,
3043 UINT *pnDetectedCodePages,
3044 WCHAR *lpSpecialChar)
3045 {
3046 ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage3, iface);
3047 FIXME("(%p)->(%08x %p %p %u %p %p %p)\n", This, dwFlags, pStrIn,
3048 puiPreferredCodePages, nPreferredCodePages, puiDetectedCodePages,
3049 pnDetectedCodePages, lpSpecialChar);
3050 return E_NOTIMPL;
3051 }
3052
3053 static const IMultiLanguage3Vtbl IMultiLanguage3_vtbl =
3054 {
3055 fnIMultiLanguage2_QueryInterface,
3056 fnIMultiLanguage2_AddRef,
3057 fnIMultiLanguage2_Release,
3058 fnIMultiLanguage2_GetNumberOfCodePageInfo,
3059 fnIMultiLanguage2_GetCodePageInfo,
3060 fnIMultiLanguage2_GetFamilyCodePage,
3061 fnIMultiLanguage2_EnumCodePages,
3062 fnIMultiLanguage2_GetCharsetInfo,
3063 fnIMultiLanguage2_IsConvertible,
3064 fnIMultiLanguage2_ConvertString,
3065 fnIMultiLanguage2_ConvertStringToUnicode,
3066 fnIMultiLanguage2_ConvertStringFromUnicode,
3067 fnIMultiLanguage2_ConvertStringReset,
3068 fnIMultiLanguage2_GetRfc1766FromLcid,
3069 fnIMultiLanguage2_GetLcidFromRfc1766,
3070 fnIMultiLanguage2_EnumRfc1766,
3071 fnIMultiLanguage2_GetRfc1766Info,
3072 fnIMultiLanguage2_CreateConvertCharset,
3073 fnIMultiLanguage2_ConvertStringInIStream,
3074 fnIMultiLanguage2_ConvertStringToUnicodeEx,
3075 fnIMultiLanguage2_ConvertStringFromUnicodeEx,
3076 fnIMultiLanguage2_DetectCodepageInIStream,
3077 fnIMultiLanguage2_DetectInputCodepage,
3078 fnIMultiLanguage2_ValidateCodePage,
3079 fnIMultiLanguage2_GetCodePageDescription,
3080 fnIMultiLanguage2_IsCodePageInstallable,
3081 fnIMultiLanguage2_SetMimeDBSource,
3082 fnIMultiLanguage2_GetNumberOfScripts,
3083 fnIMultiLanguage2_EnumScripts,
3084 fnIMultiLanguage2_ValidateCodePageEx,
3085 fnIMultiLanguage3_DetectOutboundCodePage,
3086 fnIMultiLanguage3_DetectOutboundCodePageInIStream
3087 };
3088
3089 /******************************************************************************/
3090 static HRESULT WINAPI fnIMLangFontLink2_QueryInterface(
3091 IMLangFontLink2 * iface,
3092 REFIID riid,
3093 void** ppvObject)
3094 {
3095 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink2, iface);
3096 return MLang_QueryInterface( This, riid, ppvObject );
3097 }
3098
3099 static ULONG WINAPI fnIMLangFontLink2_AddRef( IMLangFontLink2* iface )
3100 {
3101 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink2, iface);
3102 return MLang_AddRef( This );
3103 }
3104
3105 static ULONG WINAPI fnIMLangFontLink2_Release( IMLangFontLink2* iface )
3106 {
3107 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink2, iface);
3108 return MLang_Release( This );
3109 }
3110
3111 static HRESULT WINAPI fnIMLangFontLink2_GetCharCodePages( IMLangFontLink2* This,
3112 WCHAR chSrc, DWORD *pdwCodePages)
3113 {
3114 FIXME("(%p)->%s %p\n",This, debugstr_wn(&chSrc,1),pdwCodePages);
3115 return E_NOTIMPL;
3116 }
3117
3118 static HRESULT WINAPI fnIMLangFontLink2_GetStrCodePages( IMLangFontLink2* This,
3119 const WCHAR *pszSrc, long cchSrc, DWORD dwPriorityCodePages,
3120 DWORD *pdwCodePages, long *pcchCodePages)
3121 {
3122 FIXME("(%p)->%s %li %x %p %p\n",This, debugstr_wn(pszSrc,cchSrc),cchSrc,dwPriorityCodePages,pdwCodePages,pcchCodePages);
3123 *pdwCodePages = 0;
3124 *pcchCodePages = 1;
3125 return S_OK;
3126 }
3127
3128 static HRESULT WINAPI fnIMLangFontLink2_CodePageToCodePages(IMLangFontLink2* This,
3129 UINT uCodePage,
3130 DWORD *pdwCodePages)
3131 {
3132 FIXME("(%p)->%i %p\n",This, uCodePage, pdwCodePages);
3133 return E_NOTIMPL;
3134 }
3135
3136 static HRESULT WINAPI fnIMLangFontLink2_CodePagesToCodePage(IMLangFontLink2* This,
3137 DWORD dwCodePages, UINT uDefaultCodePage, UINT *puCodePage)
3138 {
3139 FIXME("(%p)->%i %i %p\n",This, dwCodePages, uDefaultCodePage, puCodePage);
3140 return E_NOTIMPL;
3141 }
3142
3143 static HRESULT WINAPI fnIMLangFontLink2_GetFontCodePages(IMLangFontLink2* This,
3144 HDC hDC, HFONT hFont, DWORD *pdwCodePages)
3145 {
3146 FIXME("(%p)->%p %p %p\n",This, hDC, hFont, pdwCodePages);
3147 return E_NOTIMPL;
3148 }
3149
3150 static HRESULT WINAPI fnIMLangFontLink2_ReleaseFont(IMLangFontLink2* This,
3151 HFONT hFont)
3152 {
3153 FIXME("(%p)->%p\n",This, hFont);
3154 return E_NOTIMPL;
3155 }
3156
3157 static HRESULT WINAPI fnIMLangFontLink2_ResetFontMapping(IMLangFontLink2* This)
3158 {
3159 FIXME("(%p)->\n",This);
3160 return E_NOTIMPL;
3161 }
3162
3163 static HRESULT WINAPI fnIMLangFontLink2_MapFont(IMLangFontLink2* This,
3164 HDC hDC, DWORD dwCodePages, WCHAR chSrc, HFONT *pFont)
3165 {
3166 FIXME("(%p)->%p %i %s %p\n",This, hDC, dwCodePages, debugstr_wn(&chSrc,1), pFont);
3167 return E_NOTIMPL;
3168 }
3169
3170 static HRESULT WINAPI fnIMLangFontLink2_GetFontUnicodeRanges(IMLangFontLink2* This,
3171 HDC hDC, UINT *puiRanges, UNICODERANGE *pUranges)
3172 {
3173 FIXME("(%p)->%p %p %p\n",This, hDC, puiRanges, pUranges);
3174 return E_NOTIMPL;
3175 }
3176
3177 static HRESULT WINAPI fnIMLangFontLink2_GetScriptFontInfo(IMLangFontLink2* This,
3178 SCRIPT_ID sid, DWORD dwFlags, UINT *puiFonts,
3179 SCRIPTFONTINFO *pScriptFont)
3180 {
3181 UINT i, j;
3182
3183 TRACE("(%p)->%u %x %p %p\n", This, sid, dwFlags, puiFonts, pScriptFont);
3184
3185 if (!dwFlags) dwFlags = SCRIPTCONTF_PROPORTIONAL_FONT;
3186
3187 for (i = 0, j = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
3188 {
3189 if (sid == mlang_data[i].sid)
3190 {
3191 if (pScriptFont)
3192 {
3193 if (j >= *puiFonts) break;
3194
3195 pScriptFont[j].scripts = 1 << mlang_data[i].sid;
3196 if (dwFlags == SCRIPTCONTF_FIXED_FONT)
3197 {
3198 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].fixed_font, -1,
3199 pScriptFont[j].wszFont, MAX_MIMEFACE_NAME);
3200 }
3201 else if (dwFlags == SCRIPTCONTF_PROPORTIONAL_FONT)
3202 {
3203 MultiByteToWideChar(CP_ACP, 0, mlang_data[i].proportional_font, -1,
3204 pScriptFont[j].wszFont, MAX_MIMEFACE_NAME);
3205 }
3206 }
3207 j++;
3208 }
3209 }
3210 *puiFonts = j;
3211 return S_OK;
3212 }
3213
3214 static HRESULT WINAPI fnIMLangFontLink2_CodePageToScriptID(IMLangFontLink2* This,
3215 UINT uiCodePage, SCRIPT_ID *pSid)
3216 {
3217 FIXME("(%p)->%i %p\n",This, uiCodePage, pSid);
3218 return E_NOTIMPL;
3219 }
3220
3221 static const IMLangFontLink2Vtbl IMLangFontLink2_vtbl =
3222 {
3223 fnIMLangFontLink2_QueryInterface,
3224 fnIMLangFontLink2_AddRef,
3225 fnIMLangFontLink2_Release,
3226 fnIMLangFontLink2_GetCharCodePages,
3227 fnIMLangFontLink2_GetStrCodePages,
3228 fnIMLangFontLink2_CodePageToCodePages,
3229 fnIMLangFontLink2_CodePagesToCodePage,
3230 fnIMLangFontLink2_GetFontCodePages,
3231 fnIMLangFontLink2_ReleaseFont,
3232 fnIMLangFontLink2_ResetFontMapping,
3233 fnIMLangFontLink2_MapFont,
3234 fnIMLangFontLink2_GetFontUnicodeRanges,
3235 fnIMLangFontLink2_GetScriptFontInfo,
3236 fnIMLangFontLink2_CodePageToScriptID
3237 };
3238
3239 /******************************************************************************/
3240
3241 static HRESULT WINAPI fnIMLangLineBreakConsole_QueryInterface(
3242 IMLangLineBreakConsole* iface,
3243 REFIID riid,
3244 void** ppvObject)
3245 {
3246 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangLineBreakConsole, iface);
3247 return MLang_QueryInterface( This, riid, ppvObject );
3248 }
3249
3250 static ULONG WINAPI fnIMLangLineBreakConsole_AddRef(
3251 IMLangLineBreakConsole* iface )
3252 {
3253 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangLineBreakConsole, iface);
3254 return MLang_AddRef( This );
3255 }
3256
3257 static ULONG WINAPI fnIMLangLineBreakConsole_Release(
3258 IMLangLineBreakConsole* iface )
3259 {
3260 ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangLineBreakConsole, iface);
3261 return MLang_Release( This );
3262 }
3263
3264 static HRESULT WINAPI fnIMLangLineBreakConsole_BreakLineML(
3265 IMLangLineBreakConsole* iface,
3266 IMLangString* pSrcMLStr,
3267 long lSrcPos,
3268 long lSrcLen,
3269 long cMinColumns,
3270 long cMaxColumns,
3271 long* plLineLen,
3272 long* plSkipLen)
3273 {
3274 FIXME("(%p)->%p %li %li %li %li %p %p\n", iface, pSrcMLStr, lSrcPos, lSrcLen, cMinColumns, cMaxColumns, plLineLen, plSkipLen);
3275 return E_NOTIMPL;
3276 }
3277
3278 static HRESULT WINAPI fnIMLangLineBreakConsole_BreakLineW(
3279 IMLangLineBreakConsole* iface,
3280 LCID locale,
3281 const WCHAR* pszSrc,
3282 long cchSrc,
3283 long cMaxColumns,
3284 long* pcchLine,
3285 long* pcchSkip )
3286 {
3287 FIXME("(%p)->%i %s %li %li %p %p\n", iface, locale, debugstr_wn(pszSrc,cchSrc), cchSrc, cMaxColumns, pcchLine, pcchSkip);
3288
3289 *pcchLine = cchSrc;
3290 *pcchSkip = 0;
3291 return S_OK;
3292 }
3293
3294 static HRESULT WINAPI fnIMLangLineBreakConsole_BreakLineA(
3295 IMLangLineBreakConsole* iface,
3296 LCID locale,
3297 UINT uCodePage,
3298 const CHAR* pszSrc,
3299 long cchSrc,
3300 long cMaxColumns,
3301 long* pcchLine,
3302 long* pcchSkip)
3303 {
3304 FIXME("(%p)->%i %i %s %li %li %p %p\n", iface, locale, uCodePage, debugstr_an(pszSrc,cchSrc), cchSrc, cMaxColumns, pcchLine, pcchSkip);
3305
3306 *pcchLine = cchSrc;
3307 *pcchSkip = 0;
3308 return S_OK;
3309 }
3310
3311 static const IMLangLineBreakConsoleVtbl IMLangLineBreakConsole_vtbl =
3312 {
3313 fnIMLangLineBreakConsole_QueryInterface,
3314 fnIMLangLineBreakConsole_AddRef,
3315 fnIMLangLineBreakConsole_Release,
3316 fnIMLangLineBreakConsole_BreakLineML,
3317 fnIMLangLineBreakConsole_BreakLineW,
3318 fnIMLangLineBreakConsole_BreakLineA
3319 };
3320
3321 static HRESULT MultiLanguage_create(IUnknown *pUnkOuter, LPVOID *ppObj)
3322 {
3323 MLang_impl *mlang;
3324 UINT i;
3325
3326 TRACE("Creating MultiLanguage object\n");
3327
3328 if( pUnkOuter )
3329 return CLASS_E_NOAGGREGATION;
3330
3331 mlang = HeapAlloc( GetProcessHeap(), 0, sizeof (MLang_impl) );
3332 mlang->vtbl_IMLangFontLink = &IMLangFontLink_vtbl;
3333 mlang->vtbl_IMultiLanguage = &IMultiLanguage_vtbl;
3334 mlang->vtbl_IMultiLanguage3 = &IMultiLanguage3_vtbl;
3335 mlang->vtbl_IMLangFontLink2 = &IMLangFontLink2_vtbl;
3336 mlang->vtbl_IMLangLineBreakConsole = &IMLangLineBreakConsole_vtbl;
3337
3338 mlang->total_cp = 0;
3339 for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
3340 mlang->total_cp += mlang_data[i].number_of_cp;
3341
3342 /* do not enumerate unicode flavours */
3343 mlang->total_scripts = sizeof(mlang_data)/sizeof(mlang_data[0]) - 1;
3344
3345 mlang->ref = 1;
3346 *ppObj = mlang;
3347 TRACE("returning %p\n", mlang);
3348
3349 LockModule();
3350
3351 return S_OK;
3352 }
3353
3354 /******************************************************************************/
3355
3356 HRESULT WINAPI DllCanUnloadNow(void)
3357 {
3358 return dll_count == 0 ? S_OK : S_FALSE;
3359 }
3360
3361 HRESULT WINAPI GetGlobalFontLinkObject(void)
3362 {
3363 FIXME("\n");
3364 return S_FALSE;
3365 }
Maarten's multimedia branch