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