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