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