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