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