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