git.oblomov.eu Git - wine/blob - dlls/mlang/mlang.c

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