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 /******************************************************************************/
1437
1438 typedef struct tagEnumCodePage_impl
1439 {
1440     IEnumCodePage IEnumCodePage_iface;
1441     LONG ref;
1442     MIMECPINFO *cpinfo;
1443     DWORD total, pos;
1444 } EnumCodePage_impl;
1445
1446 static inline EnumCodePage_impl *impl_from_IEnumCodePage( IEnumCodePage *iface )
1447 {
1448     return CONTAINING_RECORD( iface, EnumCodePage_impl, IEnumCodePage_iface );
1449 }
1450
1451 static HRESULT WINAPI fnIEnumCodePage_QueryInterface(
1452         IEnumCodePage* iface,
1453         REFIID riid,
1454         void** ppvObject)
1455 {
1456     EnumCodePage_impl *This = impl_from_IEnumCodePage( iface );
1457
1458     TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1459
1460     if (IsEqualGUID(riid, &IID_IUnknown)
1461         || IsEqualGUID(riid, &IID_IEnumCodePage))
1462     {
1463         IEnumCodePage_AddRef(iface);
1464         TRACE("Returning IID_IEnumCodePage %p ref = %d\n", This, This->ref);
1465         *ppvObject = &This->IEnumCodePage_iface;
1466         return S_OK;
1467     }
1468
1469     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1470     return E_NOINTERFACE;
1471 }
1472
1473 static ULONG WINAPI fnIEnumCodePage_AddRef(
1474         IEnumCodePage* iface)
1475 {
1476     EnumCodePage_impl *This = impl_from_IEnumCodePage( iface );
1477     return InterlockedIncrement(&This->ref);
1478 }
1479
1480 static ULONG WINAPI fnIEnumCodePage_Release(
1481         IEnumCodePage* iface)
1482 {
1483     EnumCodePage_impl *This = impl_from_IEnumCodePage( iface );
1484     ULONG ref = InterlockedDecrement(&This->ref);
1485
1486     TRACE("%p ref = %d\n", This, ref);
1487     if (ref == 0)
1488     {
1489         TRACE("Destroying %p\n", This);
1490         HeapFree(GetProcessHeap(), 0, This->cpinfo);
1491         HeapFree(GetProcessHeap(), 0, This);
1492     }
1493
1494     return ref;
1495 }
1496
1497 static HRESULT WINAPI fnIEnumCodePage_Clone(
1498         IEnumCodePage* iface,
1499         IEnumCodePage** ppEnum)
1500 {
1501     EnumCodePage_impl *This = impl_from_IEnumCodePage( iface );
1502     FIXME("%p %p\n", This, ppEnum);
1503     return E_NOTIMPL;
1504 }
1505
1506 static  HRESULT WINAPI fnIEnumCodePage_Next(
1507         IEnumCodePage* iface,
1508         ULONG celt,
1509         PMIMECPINFO rgelt,
1510         ULONG* pceltFetched)
1511 {
1512     ULONG i;
1513     EnumCodePage_impl *This = impl_from_IEnumCodePage( iface );
1514
1515     TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
1516
1517     if (!pceltFetched) return S_FALSE;
1518     *pceltFetched = 0;
1519
1520     if (!rgelt) return S_FALSE;
1521
1522     if (This->pos + celt > This->total)
1523         celt = This->total - This->pos;
1524
1525     if (!celt) return S_FALSE;
1526
1527     memcpy(rgelt, This->cpinfo + This->pos, celt * sizeof(MIMECPINFO));
1528     *pceltFetched = celt;
1529     This->pos += celt;
1530
1531     for (i = 0; i < celt; i++)
1532     {
1533         TRACE("#%u: %08x %u %u %s %s %s %s %s %s %d\n",
1534               i, rgelt[i].dwFlags, rgelt[i].uiCodePage,
1535               rgelt[i].uiFamilyCodePage,
1536               wine_dbgstr_w(rgelt[i].wszDescription),
1537               wine_dbgstr_w(rgelt[i].wszWebCharset),
1538               wine_dbgstr_w(rgelt[i].wszHeaderCharset),
1539               wine_dbgstr_w(rgelt[i].wszBodyCharset),
1540               wine_dbgstr_w(rgelt[i].wszFixedWidthFont),
1541               wine_dbgstr_w(rgelt[i].wszProportionalFont),
1542               rgelt[i].bGDICharset);
1543     }
1544     return S_OK;
1545 }
1546
1547 static HRESULT WINAPI fnIEnumCodePage_Reset(
1548         IEnumCodePage* iface)
1549 {
1550     EnumCodePage_impl *This = impl_from_IEnumCodePage( iface );
1551
1552     TRACE("%p\n", This);
1553
1554     This->pos = 0;
1555     return S_OK;
1556 }
1557
1558 static  HRESULT WINAPI fnIEnumCodePage_Skip(
1559         IEnumCodePage* iface,
1560         ULONG celt)
1561 {
1562     EnumCodePage_impl *This = impl_from_IEnumCodePage( iface );
1563
1564     TRACE("%p %u\n", This, celt);
1565
1566     if (celt >= This->total) return S_FALSE;
1567
1568     This->pos += celt;
1569     return S_OK;
1570 }
1571
1572 static const IEnumCodePageVtbl IEnumCodePage_vtbl =
1573 {
1574     fnIEnumCodePage_QueryInterface,
1575     fnIEnumCodePage_AddRef,
1576     fnIEnumCodePage_Release,
1577     fnIEnumCodePage_Clone,
1578     fnIEnumCodePage_Next,
1579     fnIEnumCodePage_Reset,
1580     fnIEnumCodePage_Skip
1581 };
1582
1583 static HRESULT EnumCodePage_create( MLang_impl* mlang, DWORD grfFlags,
1584                      LANGID LangId, IEnumCodePage** ppEnumCodePage )
1585 {
1586     EnumCodePage_impl *ecp;
1587     MIMECPINFO *cpinfo;
1588     UINT i, n;
1589
1590     TRACE("%p, %08x, %04x, %p\n", mlang, grfFlags, LangId, ppEnumCodePage);
1591
1592     if (!grfFlags) /* enumerate internal data base of encodings */
1593         grfFlags = MIMECONTF_MIME_LATEST;
1594
1595     ecp = HeapAlloc( GetProcessHeap(), 0, sizeof (EnumCodePage_impl) );
1596     ecp->IEnumCodePage_iface.lpVtbl = &IEnumCodePage_vtbl;
1597     ecp->ref = 1;
1598     ecp->pos = 0;
1599     ecp->total = 0;
1600     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1601     {
1602         for (n = 0; n < mlang_data[i].number_of_cp; n++)
1603         {
1604             if (mlang_data[i].mime_cp_info[n].flags & grfFlags)
1605                 ecp->total++;
1606         }
1607     }
1608
1609     ecp->cpinfo = HeapAlloc(GetProcessHeap(), 0,
1610                             sizeof(MIMECPINFO) * ecp->total);
1611     cpinfo = ecp->cpinfo;
1612
1613     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1614     {
1615         for (n = 0; n < mlang_data[i].number_of_cp; n++)
1616         {
1617             if (mlang_data[i].mime_cp_info[n].flags & grfFlags)
1618                 fill_cp_info(&mlang_data[i], n, cpinfo++);
1619         }
1620     }
1621
1622     TRACE("enumerated %d codepages with flags %08x\n", ecp->total, grfFlags);
1623
1624     *ppEnumCodePage = &ecp->IEnumCodePage_iface;
1625
1626     return S_OK;
1627 }
1628
1629 /******************************************************************************/
1630
1631 typedef struct tagEnumScript_impl
1632 {
1633     IEnumScript IEnumScript_iface;
1634     LONG ref;
1635     SCRIPTINFO *script_info;
1636     DWORD total, pos;
1637 } EnumScript_impl;
1638
1639 static inline EnumScript_impl *impl_from_IEnumScript( IEnumScript *iface )
1640 {
1641     return CONTAINING_RECORD( iface, EnumScript_impl, IEnumScript_iface );
1642 }
1643
1644 static HRESULT WINAPI fnIEnumScript_QueryInterface(
1645         IEnumScript* iface,
1646         REFIID riid,
1647         void** ppvObject)
1648 {
1649     EnumScript_impl *This = impl_from_IEnumScript( iface );
1650
1651     TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1652
1653     if (IsEqualGUID(riid, &IID_IUnknown)
1654         || IsEqualGUID(riid, &IID_IEnumScript))
1655     {
1656         IEnumScript_AddRef(iface);
1657         TRACE("Returning IID_IEnumScript %p ref = %d\n", This, This->ref);
1658         *ppvObject = &This->IEnumScript_iface;
1659         return S_OK;
1660     }
1661
1662     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1663     return E_NOINTERFACE;
1664 }
1665
1666 static ULONG WINAPI fnIEnumScript_AddRef(
1667         IEnumScript* iface)
1668 {
1669     EnumScript_impl *This = impl_from_IEnumScript( iface );
1670     return InterlockedIncrement(&This->ref);
1671 }
1672
1673 static ULONG WINAPI fnIEnumScript_Release(
1674         IEnumScript* iface)
1675 {
1676     EnumScript_impl *This = impl_from_IEnumScript( iface );
1677     ULONG ref = InterlockedDecrement(&This->ref);
1678
1679     TRACE("%p ref = %d\n", This, ref);
1680     if (ref == 0)
1681     {
1682         TRACE("Destroying %p\n", This);
1683         HeapFree(GetProcessHeap(), 0, This->script_info);
1684         HeapFree(GetProcessHeap(), 0, This);
1685     }
1686
1687     return ref;
1688 }
1689
1690 static HRESULT WINAPI fnIEnumScript_Clone(
1691         IEnumScript* iface,
1692         IEnumScript** ppEnum)
1693 {
1694     EnumScript_impl *This = impl_from_IEnumScript( iface );
1695     FIXME("%p %p: stub!\n", This, ppEnum);
1696     return E_NOTIMPL;
1697 }
1698
1699 static  HRESULT WINAPI fnIEnumScript_Next(
1700         IEnumScript* iface,
1701         ULONG celt,
1702         PSCRIPTINFO rgelt,
1703         ULONG* pceltFetched)
1704 {
1705     EnumScript_impl *This = impl_from_IEnumScript( iface );
1706
1707     TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
1708
1709     if (!pceltFetched || !rgelt) return E_FAIL;
1710
1711     *pceltFetched = 0;
1712
1713     if (This->pos + celt > This->total)
1714         celt = This->total - This->pos;
1715
1716     if (!celt) return S_FALSE;
1717
1718     memcpy(rgelt, This->script_info + This->pos, celt * sizeof(SCRIPTINFO));
1719     *pceltFetched = celt;
1720     This->pos += celt;
1721
1722     return S_OK;
1723 }
1724
1725 static HRESULT WINAPI fnIEnumScript_Reset(
1726         IEnumScript* iface)
1727 {
1728     EnumScript_impl *This = impl_from_IEnumScript( iface );
1729
1730     TRACE("%p\n", This);
1731
1732     This->pos = 0;
1733     return S_OK;
1734 }
1735
1736 static  HRESULT WINAPI fnIEnumScript_Skip(
1737         IEnumScript* iface,
1738         ULONG celt)
1739 {
1740     EnumScript_impl *This = impl_from_IEnumScript( iface );
1741
1742     TRACE("%p %u\n", This, celt);
1743
1744     if (celt >= This->total) return S_FALSE;
1745
1746     This->pos += celt;
1747     return S_OK;
1748 }
1749
1750 static const IEnumScriptVtbl IEnumScript_vtbl =
1751 {
1752     fnIEnumScript_QueryInterface,
1753     fnIEnumScript_AddRef,
1754     fnIEnumScript_Release,
1755     fnIEnumScript_Clone,
1756     fnIEnumScript_Next,
1757     fnIEnumScript_Reset,
1758     fnIEnumScript_Skip
1759 };
1760
1761 static HRESULT EnumScript_create( MLang_impl* mlang, DWORD dwFlags,
1762                      LANGID LangId, IEnumScript** ppEnumScript )
1763 {
1764     EnumScript_impl *es;
1765     UINT i;
1766
1767     TRACE("%p, %08x, %04x, %p: stub!\n", mlang, dwFlags, LangId, ppEnumScript);
1768
1769     if (!dwFlags) /* enumerate all available scripts */
1770         dwFlags = SCRIPTCONTF_SCRIPT_USER | SCRIPTCONTF_SCRIPT_HIDE | SCRIPTCONTF_SCRIPT_SYSTEM;
1771
1772     es = HeapAlloc( GetProcessHeap(), 0, sizeof (EnumScript_impl) );
1773     es->IEnumScript_iface.lpVtbl = &IEnumScript_vtbl;
1774     es->ref = 1;
1775     es->pos = 0;
1776     /* do not enumerate unicode flavours */
1777     es->total = sizeof(mlang_data)/sizeof(mlang_data[0]) - 1;
1778     es->script_info = HeapAlloc(GetProcessHeap(), 0, sizeof(SCRIPTINFO) * es->total);
1779
1780     for (i = 0; i < es->total; i++)
1781     {
1782         es->script_info[i].ScriptId = i;
1783         es->script_info[i].uiCodePage = mlang_data[i].family_codepage;
1784         MultiByteToWideChar(CP_ACP, 0, mlang_data[i].description, -1,
1785             es->script_info[i].wszDescription, MAX_SCRIPT_NAME);
1786         MultiByteToWideChar(CP_ACP, 0, mlang_data[i].fixed_font, -1,
1787             es->script_info[i].wszFixedWidthFont, MAX_MIMEFACE_NAME);
1788         MultiByteToWideChar(CP_ACP, 0, mlang_data[i].proportional_font, -1,
1789             es->script_info[i].wszProportionalFont, MAX_MIMEFACE_NAME);
1790     }
1791
1792     TRACE("enumerated %d scripts with flags %08x\n", es->total, dwFlags);
1793
1794     *ppEnumScript = &es->IEnumScript_iface;
1795
1796     return S_OK;
1797 }
1798
1799 /******************************************************************************/
1800
1801 static inline MLang_impl *impl_from_IMLangFontLink( IMLangFontLink *iface )
1802 {
1803     return CONTAINING_RECORD( iface, MLang_impl, IMLangFontLink_iface );
1804 }
1805
1806 static HRESULT WINAPI fnIMLangFontLink_QueryInterface(
1807         IMLangFontLink* iface,
1808         REFIID riid,
1809         void** ppvObject)
1810 {
1811     MLang_impl *This = impl_from_IMLangFontLink( iface );
1812     return IMultiLanguage3_QueryInterface( &This->IMultiLanguage3_iface, riid, ppvObject );
1813 }
1814
1815 static ULONG WINAPI fnIMLangFontLink_AddRef(
1816         IMLangFontLink* iface)
1817 {
1818     MLang_impl *This = impl_from_IMLangFontLink( iface );
1819     return IMultiLanguage3_AddRef( &This->IMultiLanguage3_iface );
1820 }
1821
1822 static ULONG WINAPI fnIMLangFontLink_Release(
1823         IMLangFontLink* iface)
1824 {
1825     MLang_impl *This = impl_from_IMLangFontLink( iface );
1826     return IMultiLanguage3_Release( &This->IMultiLanguage3_iface );
1827 }
1828
1829 static HRESULT WINAPI fnIMLangFontLink_GetCharCodePages(
1830         IMLangFontLink* iface,
1831         WCHAR chSrc,
1832         DWORD* pdwCodePages)
1833 {
1834     int i;
1835     CHAR buf;
1836     BOOL used_dc;
1837     DWORD codePages;
1838
1839     *pdwCodePages = 0;
1840
1841     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1842     {
1843         WideCharToMultiByte(mlang_data[i].family_codepage, WC_NO_BEST_FIT_CHARS,
1844             &chSrc, 1, &buf, 1, NULL, &used_dc);
1845
1846         /* If default char is not used, current codepage include the given symbol */
1847         if (!used_dc)
1848         {
1849             IMLangFontLink_CodePageToCodePages(iface,
1850                 mlang_data[i].family_codepage, &codePages);
1851             *pdwCodePages |= codePages;
1852         }
1853     }
1854     return S_OK;
1855 }
1856
1857 static HRESULT WINAPI fnIMLangFontLink_GetStrCodePages(
1858         IMLangFontLink* iface,
1859         const WCHAR* pszSrc,
1860         LONG cchSrc,
1861         DWORD dwPriorityCodePages,
1862         DWORD* pdwCodePages,
1863         LONG* pcchCodePages)
1864 {
1865     LONG i;
1866     DWORD cps = 0;
1867
1868     TRACE("(%p)->%s %d %x %p %p\n", iface, debugstr_wn(pszSrc, cchSrc), cchSrc, dwPriorityCodePages, pdwCodePages, pcchCodePages);
1869
1870     if (pdwCodePages) *pdwCodePages = 0;
1871     if (pcchCodePages) *pcchCodePages = 0;
1872
1873     if (!pszSrc || !cchSrc || cchSrc < 0)
1874         return E_INVALIDARG;
1875
1876     for (i = 0; i < cchSrc; i++)
1877     {
1878         DWORD cp;
1879         HRESULT ret;
1880
1881         ret = fnIMLangFontLink_GetCharCodePages(iface, pszSrc[i], &cp);
1882         if (ret != S_OK) return E_FAIL;
1883
1884         if (!cps) cps = cp;
1885         else cps &= cp;
1886
1887         /* FIXME: not tested */
1888         if (dwPriorityCodePages & cps) break;
1889     }
1890
1891     if (pdwCodePages) *pdwCodePages = cps;
1892     if (pcchCodePages) *pcchCodePages = min( i + 1, cchSrc );
1893     return S_OK;
1894 }
1895
1896 static HRESULT WINAPI fnIMLangFontLink_CodePageToCodePages(
1897         IMLangFontLink* iface,
1898         UINT uCodePage,
1899         DWORD* pdwCodePages)
1900 {
1901     MLang_impl *This = impl_from_IMLangFontLink( iface );
1902     CHARSETINFO cs;
1903     BOOL rc;
1904
1905     TRACE("(%p) Seeking %u\n",This, uCodePage);
1906
1907     rc = TranslateCharsetInfo((DWORD*)(DWORD_PTR)uCodePage, &cs, TCI_SRCCODEPAGE);
1908
1909     if (rc)
1910     {
1911         *pdwCodePages = cs.fs.fsCsb[0];
1912         TRACE("resulting CodePages 0x%x\n",*pdwCodePages);
1913         return S_OK;
1914     }
1915
1916     TRACE("CodePage Not Found\n");
1917     *pdwCodePages = 0;
1918     return E_FAIL;
1919 }
1920
1921 static HRESULT WINAPI fnIMLangFontLink_CodePagesToCodePage(
1922         IMLangFontLink* iface,
1923         DWORD dwCodePages,
1924         UINT uDefaultCodePage,
1925         UINT* puCodePage)
1926 {
1927     MLang_impl *This = impl_from_IMLangFontLink( iface );
1928     DWORD mask = 0x00000000;
1929     UINT i;
1930     CHARSETINFO cs;
1931     BOOL rc;
1932
1933     TRACE("(%p) scanning  0x%x  default page %u\n",This, dwCodePages,
1934             uDefaultCodePage);
1935
1936     *puCodePage = 0x00000000;
1937
1938     rc = TranslateCharsetInfo((DWORD*)(DWORD_PTR)uDefaultCodePage, &cs,
1939                               TCI_SRCCODEPAGE);
1940
1941     if (rc && (dwCodePages & cs.fs.fsCsb[0]))
1942     {
1943         TRACE("Found Default Codepage\n");
1944         *puCodePage = uDefaultCodePage;
1945         return S_OK;
1946     }
1947
1948
1949     for (i = 0; i < 32; i++)
1950     {
1951
1952         mask = 1 << i;
1953         if (dwCodePages & mask)
1954         {
1955             DWORD Csb[2];
1956             Csb[0] = mask;
1957             Csb[1] = 0x0;
1958             rc = TranslateCharsetInfo(Csb, &cs, TCI_SRCFONTSIG);
1959             if (!rc)
1960                 continue;
1961
1962             TRACE("Falling back to least significant found CodePage %u\n",
1963                     cs.ciACP);
1964             *puCodePage = cs.ciACP;
1965             return S_OK;
1966         }
1967     }
1968
1969     TRACE("no codepage found\n");
1970     return E_FAIL;
1971 }
1972
1973 static HRESULT WINAPI fnIMLangFontLink_GetFontCodePages(
1974         IMLangFontLink* iface,
1975         HDC hDC,
1976         HFONT hFont,
1977         DWORD* pdwCodePages)
1978 {
1979     HFONT old_font;
1980     FONTSIGNATURE fontsig;
1981     MLang_impl *This = impl_from_IMLangFontLink( iface );
1982
1983     TRACE("(%p)\n",This);
1984
1985     old_font = SelectObject(hDC,hFont);
1986     GetTextCharsetInfo(hDC,&fontsig, 0);
1987     SelectObject(hDC,old_font);
1988
1989     *pdwCodePages = fontsig.fsCsb[0];
1990     TRACE("CodePages is 0x%x\n",fontsig.fsCsb[0]);
1991
1992     return S_OK;
1993 }
1994
1995 static HRESULT WINAPI fnIMLangFontLink_MapFont(
1996         IMLangFontLink* iface,
1997         HDC hDC,
1998         DWORD dwCodePages,
1999         HFONT hSrcFont,
2000         HFONT* phDestFont)
2001 {
2002     FIXME("\n");
2003     return E_NOTIMPL;
2004 }
2005
2006 static HRESULT WINAPI fnIMLangFontLink_ReleaseFont(
2007         IMLangFontLink* iface,
2008         HFONT hFont)
2009 {
2010     FIXME("\n");
2011     return E_NOTIMPL;
2012 }
2013
2014 static HRESULT WINAPI fnIMLangFontLink_ResetFontMapping(
2015         IMLangFontLink* iface)
2016 {
2017     FIXME("\n");
2018     return E_NOTIMPL;
2019 }
2020
2021
2022 static const IMLangFontLinkVtbl IMLangFontLink_vtbl =
2023 {
2024     fnIMLangFontLink_QueryInterface,
2025     fnIMLangFontLink_AddRef,
2026     fnIMLangFontLink_Release,
2027     fnIMLangFontLink_GetCharCodePages,
2028     fnIMLangFontLink_GetStrCodePages,
2029     fnIMLangFontLink_CodePageToCodePages,
2030     fnIMLangFontLink_CodePagesToCodePage,
2031     fnIMLangFontLink_GetFontCodePages,
2032     fnIMLangFontLink_MapFont,
2033     fnIMLangFontLink_ReleaseFont,
2034     fnIMLangFontLink_ResetFontMapping,
2035 };
2036
2037 /******************************************************************************/
2038
2039 static inline MLang_impl *impl_from_IMultiLanguage( IMultiLanguage *iface )
2040 {
2041     return CONTAINING_RECORD( iface, MLang_impl, IMultiLanguage_iface );
2042 }
2043
2044 static HRESULT WINAPI fnIMultiLanguage_QueryInterface(
2045     IMultiLanguage* iface,
2046     REFIID riid,
2047     void** obj)
2048 {
2049     MLang_impl *This = impl_from_IMultiLanguage( iface );
2050     return IMultiLanguage3_QueryInterface(&This->IMultiLanguage3_iface, riid, obj);
2051 }
2052
2053 static ULONG WINAPI fnIMultiLanguage_AddRef( IMultiLanguage* iface )
2054 {
2055     MLang_impl *This = impl_from_IMultiLanguage( iface );
2056     return IMultiLanguage3_AddRef(&This->IMultiLanguage3_iface);
2057 }
2058
2059 static ULONG WINAPI fnIMultiLanguage_Release( IMultiLanguage* iface )
2060 {
2061     MLang_impl *This = impl_from_IMultiLanguage( iface );
2062     return IMultiLanguage3_Release(&This->IMultiLanguage3_iface);
2063 }
2064
2065 static HRESULT WINAPI fnIMultiLanguage_GetNumberOfCodePageInfo(
2066     IMultiLanguage* iface,
2067     UINT* cp)
2068 {
2069     MLang_impl *This = impl_from_IMultiLanguage( iface );
2070     TRACE("(%p, %p)\n", This, cp);
2071     return IMultiLanguage3_GetNumberOfCodePageInfo(&This->IMultiLanguage3_iface, cp);
2072 }
2073
2074 static HRESULT WINAPI fnIMultiLanguage_GetCodePageInfo(
2075     IMultiLanguage* iface,
2076     UINT uiCodePage,
2077     PMIMECPINFO pCodePageInfo)
2078 {
2079     UINT i, n;
2080     MLang_impl *This = impl_from_IMultiLanguage( iface );
2081
2082     TRACE("%p, %u, %p\n", This, uiCodePage, pCodePageInfo);
2083
2084     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2085     {
2086         for (n = 0; n < mlang_data[i].number_of_cp; n++)
2087         {
2088             if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
2089             {
2090                 fill_cp_info(&mlang_data[i], n, pCodePageInfo);
2091                 return S_OK;
2092             }
2093         }
2094     }
2095
2096     return S_FALSE;
2097 }
2098
2099 static HRESULT WINAPI fnIMultiLanguage_GetFamilyCodePage(
2100     IMultiLanguage* iface,
2101     UINT cp,
2102     UINT* family_cp)
2103 {
2104     MLang_impl *This = impl_from_IMultiLanguage( iface );
2105     return IMultiLanguage3_GetFamilyCodePage(&This->IMultiLanguage3_iface, cp, family_cp);
2106 }
2107
2108 static HRESULT WINAPI fnIMultiLanguage_EnumCodePages(
2109     IMultiLanguage* iface,
2110     DWORD grfFlags,
2111     IEnumCodePage** ppEnumCodePage)
2112 {
2113     MLang_impl *This = impl_from_IMultiLanguage( iface );
2114
2115     TRACE("%p %08x %p\n", This, grfFlags, ppEnumCodePage);
2116
2117     return EnumCodePage_create( This, grfFlags, 0, ppEnumCodePage );
2118 }
2119
2120 static HRESULT WINAPI fnIMultiLanguage_GetCharsetInfo(
2121     IMultiLanguage* iface,
2122     BSTR Charset,
2123     PMIMECSETINFO pCharsetInfo)
2124 {
2125     MLang_impl *This = impl_from_IMultiLanguage( iface );
2126     return IMultiLanguage3_GetCharsetInfo( &This->IMultiLanguage3_iface, Charset, pCharsetInfo );
2127 }
2128
2129 static HRESULT WINAPI fnIMultiLanguage_IsConvertible(
2130     IMultiLanguage* iface,
2131     DWORD src_enc,
2132     DWORD dst_enc)
2133 {
2134     MLang_impl *This = impl_from_IMultiLanguage( iface );
2135     return IMultiLanguage3_IsConvertible(&This->IMultiLanguage3_iface, src_enc, dst_enc);
2136 }
2137
2138 static HRESULT WINAPI fnIMultiLanguage_ConvertString(
2139     IMultiLanguage* iface,
2140     DWORD* mode,
2141     DWORD src_enc,
2142     DWORD dst_enc,
2143     BYTE* src,
2144     UINT* src_size,
2145     BYTE* dest,
2146     UINT* dest_size)
2147 {
2148     MLang_impl *This = impl_from_IMultiLanguage( iface );
2149     return IMultiLanguage3_ConvertString(&This->IMultiLanguage3_iface, mode, src_enc,
2150         dst_enc, src, src_size, dest, dest_size);
2151 }
2152
2153 static HRESULT WINAPI fnIMultiLanguage_ConvertStringToUnicode(
2154     IMultiLanguage* iface,
2155     DWORD* mode,
2156     DWORD src_enc,
2157     CHAR* src,
2158     UINT* src_size,
2159     WCHAR* dest,
2160     UINT* dest_size)
2161 {
2162     MLang_impl *This = impl_from_IMultiLanguage( iface );
2163     return IMultiLanguage3_ConvertStringToUnicode(&This->IMultiLanguage3_iface,
2164         mode, src_enc, src, src_size, dest, dest_size);
2165 }
2166
2167 static HRESULT WINAPI fnIMultiLanguage_ConvertStringFromUnicode(
2168     IMultiLanguage* iface,
2169     DWORD* pdwMode,
2170     DWORD dwEncoding,
2171     WCHAR* pSrcStr,
2172     UINT* pcSrcSize,
2173     CHAR* pDstStr,
2174     UINT* pcDstSize)
2175 {
2176     return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
2177         pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2178 }
2179
2180 static HRESULT WINAPI fnIMultiLanguage_ConvertStringReset(
2181     IMultiLanguage* iface)
2182 {
2183     MLang_impl *This = impl_from_IMultiLanguage( iface );
2184     return IMultiLanguage3_ConvertStringReset(&This->IMultiLanguage3_iface);
2185 }
2186
2187 static HRESULT WINAPI fnIMultiLanguage_GetRfc1766FromLcid(
2188     IMultiLanguage* iface,
2189     LCID lcid,
2190     BSTR* pbstrRfc1766)
2191 {
2192     MLang_impl *This = impl_from_IMultiLanguage(iface);
2193     return IMultiLanguage3_GetRfc1766FromLcid(&This->IMultiLanguage3_iface, lcid, pbstrRfc1766);
2194 }
2195
2196 static HRESULT WINAPI fnIMultiLanguage_GetLcidFromRfc1766(
2197     IMultiLanguage* iface,
2198     LCID* pLocale,
2199     BSTR bstrRfc1766)
2200 {
2201     HRESULT hr;
2202     IEnumRfc1766 *rfc1766;
2203
2204     TRACE("%p %p %s\n", iface, pLocale, debugstr_w(bstrRfc1766));
2205
2206     if (!pLocale || !bstrRfc1766)
2207         return E_INVALIDARG;
2208
2209     hr = IMultiLanguage_EnumRfc1766(iface, &rfc1766);
2210     if (FAILED(hr))
2211         return hr;
2212
2213     hr = lcid_from_rfc1766(rfc1766, pLocale, bstrRfc1766);
2214
2215     IEnumRfc1766_Release(rfc1766);
2216     return hr;
2217 }
2218
2219 /******************************************************************************/
2220
2221 typedef struct tagEnumRfc1766_impl
2222 {
2223     IEnumRfc1766 IEnumRfc1766_iface;
2224     LONG ref;
2225     RFC1766INFO *info;
2226     DWORD total, pos;
2227 } EnumRfc1766_impl;
2228
2229 static inline EnumRfc1766_impl *impl_from_IEnumRfc1766( IEnumRfc1766 *iface )
2230 {
2231     return CONTAINING_RECORD( iface, EnumRfc1766_impl, IEnumRfc1766_iface );
2232 }
2233
2234 static HRESULT WINAPI fnIEnumRfc1766_QueryInterface(
2235         IEnumRfc1766 *iface,
2236         REFIID riid,
2237         void** ppvObject)
2238 {
2239     EnumRfc1766_impl *This = impl_from_IEnumRfc1766( iface );
2240
2241     TRACE("%p -> %s\n", This, debugstr_guid(riid) );
2242
2243     if (IsEqualGUID(riid, &IID_IUnknown)
2244         || IsEqualGUID(riid, &IID_IEnumRfc1766))
2245     {
2246         IEnumRfc1766_AddRef(iface);
2247         TRACE("Returning IID_IEnumRfc1766 %p ref = %d\n", This, This->ref);
2248         *ppvObject = &This->IEnumRfc1766_iface;
2249         return S_OK;
2250     }
2251
2252     WARN("(%p) -> (%s,%p), not found\n",This,debugstr_guid(riid),ppvObject);
2253     return E_NOINTERFACE;
2254 }
2255
2256 static ULONG WINAPI fnIEnumRfc1766_AddRef(
2257         IEnumRfc1766 *iface)
2258 {
2259     EnumRfc1766_impl *This = impl_from_IEnumRfc1766( iface );
2260     return InterlockedIncrement(&This->ref);
2261 }
2262
2263 static ULONG WINAPI fnIEnumRfc1766_Release(
2264         IEnumRfc1766 *iface)
2265 {
2266     EnumRfc1766_impl *This = impl_from_IEnumRfc1766( iface );
2267     ULONG ref = InterlockedDecrement(&This->ref);
2268
2269     TRACE("%p ref = %d\n", This, ref);
2270     if (ref == 0)
2271     {
2272         TRACE("Destroying %p\n", This);
2273         HeapFree(GetProcessHeap(), 0, This->info);
2274         HeapFree(GetProcessHeap(), 0, This);
2275     }
2276     return ref;
2277 }
2278
2279 static HRESULT WINAPI fnIEnumRfc1766_Clone(
2280         IEnumRfc1766 *iface,
2281         IEnumRfc1766 **ppEnum)
2282 {
2283     EnumRfc1766_impl *This = impl_from_IEnumRfc1766( iface );
2284
2285     FIXME("%p %p\n", This, ppEnum);
2286     return E_NOTIMPL;
2287 }
2288
2289 static  HRESULT WINAPI fnIEnumRfc1766_Next(
2290         IEnumRfc1766 *iface,
2291         ULONG celt,
2292         PRFC1766INFO rgelt,
2293         ULONG *pceltFetched)
2294 {
2295     ULONG i;
2296     EnumRfc1766_impl *This = impl_from_IEnumRfc1766( iface );
2297
2298     TRACE("%p %u %p %p\n", This, celt, rgelt, pceltFetched);
2299
2300     if (!pceltFetched) return S_FALSE;
2301     *pceltFetched = 0;
2302
2303     if (!rgelt) return S_FALSE;
2304
2305     if (This->pos + celt > This->total)
2306         celt = This->total - This->pos;
2307
2308     if (!celt) return S_FALSE;
2309
2310     memcpy(rgelt, This->info + This->pos, celt * sizeof(RFC1766INFO));
2311     *pceltFetched = celt;
2312     This->pos += celt;
2313
2314     for (i = 0; i < celt; i++)
2315     {
2316         TRACE("#%u: %08x %s %s\n",
2317               i, rgelt[i].lcid,
2318               wine_dbgstr_w(rgelt[i].wszRfc1766),
2319               wine_dbgstr_w(rgelt[i].wszLocaleName));
2320     }
2321     return S_OK;
2322 }
2323
2324 static HRESULT WINAPI fnIEnumRfc1766_Reset(
2325         IEnumRfc1766 *iface)
2326 {
2327     EnumRfc1766_impl *This = impl_from_IEnumRfc1766( iface );
2328
2329     TRACE("%p\n", This);
2330
2331     This->pos = 0;
2332     return S_OK;
2333 }
2334
2335 static  HRESULT WINAPI fnIEnumRfc1766_Skip(
2336         IEnumRfc1766 *iface,
2337         ULONG celt)
2338 {
2339     EnumRfc1766_impl *This = impl_from_IEnumRfc1766( iface );
2340
2341     TRACE("%p %u\n", This, celt);
2342
2343     if (celt >= This->total) return S_FALSE;
2344
2345     This->pos += celt;
2346     return S_OK;
2347 }
2348
2349 static const IEnumRfc1766Vtbl IEnumRfc1766_vtbl =
2350 {
2351     fnIEnumRfc1766_QueryInterface,
2352     fnIEnumRfc1766_AddRef,
2353     fnIEnumRfc1766_Release,
2354     fnIEnumRfc1766_Clone,
2355     fnIEnumRfc1766_Next,
2356     fnIEnumRfc1766_Reset,
2357     fnIEnumRfc1766_Skip
2358 };
2359
2360 struct enum_locales_data
2361 {
2362     RFC1766INFO *info;
2363     DWORD total, allocated;
2364 };
2365
2366 static BOOL CALLBACK enum_locales_proc(LPWSTR locale)
2367 {
2368     WCHAR *end;
2369     struct enum_locales_data *data = TlsGetValue(MLANG_tls_index);
2370     RFC1766INFO *info;
2371
2372     TRACE("%s\n", debugstr_w(locale));
2373
2374     if (data->total >= data->allocated)
2375     {
2376         data->allocated += 32;
2377         data->info = HeapReAlloc(GetProcessHeap(), 0, data->info, data->allocated * sizeof(RFC1766INFO));
2378         if (!data->info) return FALSE;
2379     }
2380
2381     info = &data->info[data->total];
2382
2383     info->lcid = strtolW(locale, &end, 16);
2384     if (*end) /* invalid number */
2385         return FALSE;
2386
2387     info->wszRfc1766[0] = 0;
2388     lcid_to_rfc1766W( info->lcid, info->wszRfc1766, MAX_RFC1766_NAME );
2389
2390     info->wszLocaleName[0] = 0;
2391     GetLocaleInfoW(info->lcid, LOCALE_SLANGUAGE, info->wszLocaleName, MAX_LOCALE_NAME);
2392     TRACE("ISO639: %s SLANGUAGE: %s\n", wine_dbgstr_w(info->wszRfc1766), wine_dbgstr_w(info->wszLocaleName));
2393
2394     data->total++;
2395
2396     return TRUE;
2397 }
2398
2399 static HRESULT EnumRfc1766_create(LANGID LangId, IEnumRfc1766 **ppEnum)
2400 {
2401     EnumRfc1766_impl *rfc;
2402     struct enum_locales_data data;
2403
2404     TRACE("%04x, %p\n", LangId, ppEnum);
2405
2406     rfc = HeapAlloc( GetProcessHeap(), 0, sizeof(EnumRfc1766_impl) );
2407     rfc->IEnumRfc1766_iface.lpVtbl = &IEnumRfc1766_vtbl;
2408     rfc->ref = 1;
2409     rfc->pos = 0;
2410     rfc->total = 0;
2411
2412     data.total = 0;
2413     data.allocated = 160;
2414     data.info = HeapAlloc(GetProcessHeap(), 0, data.allocated * sizeof(RFC1766INFO));
2415     if (!data.info)
2416     {
2417         HeapFree(GetProcessHeap(), 0, rfc);
2418         return E_OUTOFMEMORY;
2419     }
2420
2421     TlsSetValue(MLANG_tls_index, &data);
2422     EnumSystemLocalesW(enum_locales_proc, 0/*LOCALE_SUPPORTED*/);
2423     TlsSetValue(MLANG_tls_index, NULL);
2424
2425     TRACE("enumerated %d rfc1766 structures\n", data.total);
2426
2427     if (!data.total)
2428     {
2429         HeapFree(GetProcessHeap(), 0, data.info);
2430         HeapFree(GetProcessHeap(), 0, rfc);
2431         return E_FAIL;
2432     }
2433
2434     rfc->info = data.info;
2435     rfc->total = data.total;
2436
2437     *ppEnum = &rfc->IEnumRfc1766_iface;
2438     return S_OK;
2439 }
2440
2441 static HRESULT WINAPI fnIMultiLanguage_EnumRfc1766(
2442     IMultiLanguage *iface,
2443     IEnumRfc1766 **ppEnumRfc1766)
2444 {
2445     MLang_impl *This = impl_from_IMultiLanguage( iface );
2446
2447     TRACE("%p %p\n", This, ppEnumRfc1766);
2448
2449     return EnumRfc1766_create(0, ppEnumRfc1766);
2450 }
2451
2452 /******************************************************************************/
2453
2454 static HRESULT WINAPI fnIMultiLanguage_GetRfc1766Info(
2455     IMultiLanguage* iface,
2456     LCID Locale,
2457     PRFC1766INFO pRfc1766Info)
2458 {
2459     LCTYPE type = LOCALE_SLANGUAGE;
2460
2461     TRACE("(%p, 0x%04x, %p)\n", iface, Locale, pRfc1766Info);
2462
2463     if (!pRfc1766Info)
2464         return E_INVALIDARG;
2465
2466     if ((PRIMARYLANGID(Locale) == LANG_ENGLISH) ||
2467         (PRIMARYLANGID(Locale) == LANG_CHINESE) ||
2468         (PRIMARYLANGID(Locale) == LANG_ARABIC)) {
2469
2470         if (!SUBLANGID(Locale))
2471             type = LOCALE_SENGLANGUAGE; /* suppress country */
2472     }
2473     else
2474     {
2475         if (!SUBLANGID(Locale)) {
2476             TRACE("SUBLANGID missing in 0x%04x\n", Locale);
2477             return E_FAIL;
2478         }
2479     }
2480
2481     pRfc1766Info->lcid = Locale;
2482     pRfc1766Info->wszRfc1766[0] = 0;
2483     pRfc1766Info->wszLocaleName[0] = 0;
2484
2485     if ((!lcid_to_rfc1766W(Locale, pRfc1766Info->wszRfc1766, MAX_RFC1766_NAME)) &&
2486         (GetLocaleInfoW(Locale, type, pRfc1766Info->wszLocaleName, MAX_LOCALE_NAME) > 0))
2487             return S_OK;
2488
2489     /* Locale not supported */
2490     return E_INVALIDARG;
2491 }
2492
2493 static HRESULT WINAPI fnIMultiLanguage_CreateConvertCharset(
2494     IMultiLanguage* iface,
2495     UINT src_cp,
2496     UINT dst_cp,
2497     DWORD prop,
2498     IMLangConvertCharset** convert_charset)
2499 {
2500     MLang_impl *This = impl_from_IMultiLanguage(iface);
2501     return IMultiLanguage3_CreateConvertCharset(&This->IMultiLanguage3_iface, src_cp, dst_cp, prop, convert_charset);
2502 }
2503
2504 static const IMultiLanguageVtbl IMultiLanguage_vtbl =
2505 {
2506     fnIMultiLanguage_QueryInterface,
2507     fnIMultiLanguage_AddRef,
2508     fnIMultiLanguage_Release,
2509     fnIMultiLanguage_GetNumberOfCodePageInfo,
2510     fnIMultiLanguage_GetCodePageInfo,
2511     fnIMultiLanguage_GetFamilyCodePage,
2512     fnIMultiLanguage_EnumCodePages,
2513     fnIMultiLanguage_GetCharsetInfo,
2514     fnIMultiLanguage_IsConvertible,
2515     fnIMultiLanguage_ConvertString,
2516     fnIMultiLanguage_ConvertStringToUnicode,
2517     fnIMultiLanguage_ConvertStringFromUnicode,
2518     fnIMultiLanguage_ConvertStringReset,
2519     fnIMultiLanguage_GetRfc1766FromLcid,
2520     fnIMultiLanguage_GetLcidFromRfc1766,
2521     fnIMultiLanguage_EnumRfc1766,
2522     fnIMultiLanguage_GetRfc1766Info,
2523     fnIMultiLanguage_CreateConvertCharset,
2524 };
2525
2526
2527 /******************************************************************************/
2528
2529 static inline MLang_impl *impl_from_IMultiLanguage3( IMultiLanguage3 *iface )
2530 {
2531     return CONTAINING_RECORD( iface, MLang_impl, IMultiLanguage3_iface );
2532 }
2533
2534 static HRESULT WINAPI fnIMultiLanguage2_QueryInterface(
2535     IMultiLanguage3* iface,
2536     REFIID riid,
2537     void** obj)
2538 {
2539     MLang_impl *This = impl_from_IMultiLanguage3( iface );
2540
2541     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
2542
2543     if (IsEqualGUID(riid, &IID_IUnknown) ||
2544         IsEqualGUID(riid, &IID_IMultiLanguage))
2545     {
2546         *obj = &This->IMultiLanguage_iface;
2547     }
2548     else if (IsEqualGUID(riid, &IID_IMLangCodePages) ||
2549              IsEqualGUID(riid, &IID_IMLangFontLink))
2550     {
2551         *obj = &This->IMLangFontLink_iface;
2552     }
2553     else if (IsEqualGUID(riid, &IID_IMLangFontLink2))
2554     {
2555         *obj = &This->IMLangFontLink2_iface;
2556     }
2557     else if (IsEqualGUID(riid, &IID_IMultiLanguage2) ||
2558              IsEqualGUID(riid, &IID_IMultiLanguage3))
2559     {
2560         *obj = &This->IMultiLanguage3_iface;
2561     }
2562     else if (IsEqualGUID(riid, &IID_IMLangLineBreakConsole))
2563     {
2564         *obj = &This->IMLangLineBreakConsole_iface;
2565     }
2566     else
2567     {
2568         WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), obj);
2569         *obj = NULL;
2570         return E_NOINTERFACE;
2571     }
2572
2573     IMultiLanguage3_AddRef(iface);
2574     return S_OK;
2575 }
2576
2577 static ULONG WINAPI fnIMultiLanguage2_AddRef( IMultiLanguage3* iface )
2578 {
2579     MLang_impl *This = impl_from_IMultiLanguage3( iface );
2580     return InterlockedIncrement(&This->ref);
2581 }
2582
2583 static ULONG WINAPI fnIMultiLanguage2_Release( IMultiLanguage3* iface )
2584 {
2585     MLang_impl *This = impl_from_IMultiLanguage3( iface );
2586     ULONG ref = InterlockedDecrement(&This->ref);
2587
2588     TRACE("(%p)->(%d)\n", This, ref);
2589     if (ref == 0)
2590     {
2591         HeapFree(GetProcessHeap(), 0, This);
2592         UnlockModule();
2593     }
2594
2595     return ref;
2596 }
2597
2598 static HRESULT WINAPI fnIMultiLanguage2_GetNumberOfCodePageInfo(
2599     IMultiLanguage3* iface,
2600     UINT* pcCodePage)
2601 {
2602     MLang_impl *This = impl_from_IMultiLanguage3( iface );
2603
2604     TRACE("%p, %p\n", This, pcCodePage);
2605
2606     if (!pcCodePage) return E_INVALIDARG;
2607
2608     *pcCodePage = This->total_cp;
2609     return S_OK;
2610 }
2611
2612 static void fill_cp_info(const struct mlang_data *ml_data, UINT index, MIMECPINFO *mime_cp_info)
2613 {
2614     CHARSETINFO csi;
2615
2616     if (TranslateCharsetInfo((DWORD*)(DWORD_PTR)ml_data->family_codepage, &csi,
2617                              TCI_SRCCODEPAGE))
2618         mime_cp_info->bGDICharset = csi.ciCharset;
2619     else
2620         mime_cp_info->bGDICharset = DEFAULT_CHARSET;
2621
2622     mime_cp_info->dwFlags = ml_data->mime_cp_info[index].flags;
2623     mime_cp_info->uiCodePage = ml_data->mime_cp_info[index].cp;
2624     mime_cp_info->uiFamilyCodePage = ml_data->family_codepage;
2625     MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].description, -1,
2626                         mime_cp_info->wszDescription, sizeof(mime_cp_info->wszDescription)/sizeof(WCHAR));
2627     MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].web_charset, -1,
2628                         mime_cp_info->wszWebCharset, sizeof(mime_cp_info->wszWebCharset)/sizeof(WCHAR));
2629     MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].header_charset, -1,
2630                         mime_cp_info->wszHeaderCharset, sizeof(mime_cp_info->wszHeaderCharset)/sizeof(WCHAR));
2631     MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].body_charset, -1,
2632                         mime_cp_info->wszBodyCharset, sizeof(mime_cp_info->wszBodyCharset)/sizeof(WCHAR));
2633
2634     MultiByteToWideChar(CP_ACP, 0, ml_data->fixed_font, -1,
2635         mime_cp_info->wszFixedWidthFont, sizeof(mime_cp_info->wszFixedWidthFont)/sizeof(WCHAR));
2636     MultiByteToWideChar(CP_ACP, 0, ml_data->proportional_font, -1,
2637         mime_cp_info->wszProportionalFont, sizeof(mime_cp_info->wszProportionalFont)/sizeof(WCHAR));
2638
2639     TRACE("%08x %u %u %s %s %s %s %s %s %d\n",
2640           mime_cp_info->dwFlags, mime_cp_info->uiCodePage,
2641           mime_cp_info->uiFamilyCodePage,
2642           wine_dbgstr_w(mime_cp_info->wszDescription),
2643           wine_dbgstr_w(mime_cp_info->wszWebCharset),
2644           wine_dbgstr_w(mime_cp_info->wszHeaderCharset),
2645           wine_dbgstr_w(mime_cp_info->wszBodyCharset),
2646           wine_dbgstr_w(mime_cp_info->wszFixedWidthFont),
2647           wine_dbgstr_w(mime_cp_info->wszProportionalFont),
2648           mime_cp_info->bGDICharset);
2649 }
2650
2651 static HRESULT WINAPI fnIMultiLanguage2_GetCodePageInfo(
2652     IMultiLanguage3* iface,
2653     UINT uiCodePage,
2654     LANGID LangId,
2655     PMIMECPINFO pCodePageInfo)
2656 {
2657     UINT i, n;
2658     MLang_impl *This = impl_from_IMultiLanguage3( iface );
2659
2660     TRACE("%p, %u, %04x, %p\n", This, uiCodePage, LangId, pCodePageInfo);
2661
2662     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2663     {
2664         for (n = 0; n < mlang_data[i].number_of_cp; n++)
2665         {
2666             if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
2667             {
2668                 fill_cp_info(&mlang_data[i], n, pCodePageInfo);
2669                 return S_OK;
2670             }
2671         }
2672     }
2673
2674     return S_FALSE;
2675 }
2676
2677 static HRESULT WINAPI fnIMultiLanguage2_GetFamilyCodePage(
2678     IMultiLanguage3* iface,
2679     UINT uiCodePage,
2680     UINT* puiFamilyCodePage)
2681 {
2682     return GetFamilyCodePage(uiCodePage, puiFamilyCodePage);
2683 }
2684
2685 static HRESULT WINAPI fnIMultiLanguage2_EnumCodePages(
2686     IMultiLanguage3* iface,
2687     DWORD grfFlags,
2688     LANGID LangId,
2689     IEnumCodePage** ppEnumCodePage)
2690 {
2691     MLang_impl *This = impl_from_IMultiLanguage3( iface );
2692
2693     TRACE("%p %08x %04x %p\n", This, grfFlags, LangId, ppEnumCodePage);
2694
2695     return EnumCodePage_create( This, grfFlags, LangId, ppEnumCodePage );
2696 }
2697
2698 static HRESULT WINAPI fnIMultiLanguage2_GetCharsetInfo(
2699     IMultiLanguage3* iface,
2700     BSTR Charset,
2701     PMIMECSETINFO pCharsetInfo)
2702 {
2703     UINT i, n;
2704     MLang_impl *This = impl_from_IMultiLanguage3( iface );
2705
2706     TRACE("%p %s %p\n", This, debugstr_w(Charset), pCharsetInfo);
2707
2708     if (!pCharsetInfo) return E_FAIL;
2709
2710     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2711     {
2712         for (n = 0; n < mlang_data[i].number_of_cp; n++)
2713         {
2714             WCHAR csetW[MAX_MIMECSET_NAME];
2715
2716             MultiByteToWideChar(CP_ACP, 0, mlang_data[i].mime_cp_info[n].web_charset, -1, csetW, MAX_MIMECSET_NAME);
2717             if (!lstrcmpiW(Charset, csetW))
2718             {
2719                 pCharsetInfo->uiCodePage = mlang_data[i].family_codepage;
2720                 pCharsetInfo->uiInternetEncoding = mlang_data[i].mime_cp_info[n].cp;
2721                 strcpyW(pCharsetInfo->wszCharset, csetW);
2722                 return S_OK;
2723             }
2724         }
2725     }
2726
2727     /* FIXME:
2728      * Since we do not support charsets like iso-2022-jp and do not have
2729      * them in our database as a primary (web_charset) encoding this loop
2730      * does an attempt to 'approximate' charset name by header_charset.
2731      */
2732     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
2733     {
2734         for (n = 0; n < mlang_data[i].number_of_cp; n++)
2735         {
2736             WCHAR csetW[MAX_MIMECSET_NAME];
2737
2738             MultiByteToWideChar(CP_ACP, 0, mlang_data[i].mime_cp_info[n].header_charset, -1, csetW, MAX_MIMECSET_NAME);
2739             if (!lstrcmpiW(Charset, csetW))
2740             {
2741                 pCharsetInfo->uiCodePage = mlang_data[i].family_codepage;
2742                 pCharsetInfo->uiInternetEncoding = mlang_data[i].mime_cp_info[n].cp;
2743                 strcpyW(pCharsetInfo->wszCharset, csetW);
2744                 return S_OK;
2745             }
2746         }
2747     }
2748
2749     return E_FAIL;
2750 }
2751
2752 static HRESULT WINAPI fnIMultiLanguage2_IsConvertible(
2753     IMultiLanguage3* iface,
2754     DWORD dwSrcEncoding,
2755     DWORD dwDstEncoding)
2756 {
2757     return IsConvertINetStringAvailable(dwSrcEncoding, dwDstEncoding);
2758 }
2759
2760 static HRESULT WINAPI fnIMultiLanguage2_ConvertString(
2761     IMultiLanguage3* iface,
2762     DWORD* pdwMode,
2763     DWORD dwSrcEncoding,
2764     DWORD dwDstEncoding,
2765     BYTE* pSrcStr,
2766     UINT* pcSrcSize,
2767     BYTE* pDstStr,
2768     UINT* pcDstSize)
2769 {
2770     return ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding,
2771         (LPCSTR)pSrcStr, (LPINT)pcSrcSize, (LPSTR)pDstStr, (LPINT)pcDstSize);
2772 }
2773
2774 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicode(
2775     IMultiLanguage3* iface,
2776     DWORD* pdwMode,
2777     DWORD dwEncoding,
2778     CHAR* pSrcStr,
2779     UINT* pcSrcSize,
2780     WCHAR* pDstStr,
2781     UINT* pcDstSize)
2782 {
2783     return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
2784         pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2785 }
2786
2787 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringFromUnicode(
2788     IMultiLanguage3* iface,
2789     DWORD* pdwMode,
2790     DWORD dwEncoding,
2791     WCHAR* pSrcStr,
2792     UINT* pcSrcSize,
2793     CHAR* pDstStr,
2794     UINT* pcDstSize)
2795 {
2796     return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
2797         pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2798 }
2799
2800 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringReset(
2801     IMultiLanguage3* iface)
2802 {
2803     FIXME("\n");
2804     return E_NOTIMPL;
2805 }
2806
2807 static HRESULT WINAPI fnIMultiLanguage2_GetRfc1766FromLcid(
2808     IMultiLanguage3* iface,
2809     LCID lcid,
2810     BSTR* pbstrRfc1766)
2811 {
2812     WCHAR buf[MAX_RFC1766_NAME];
2813
2814     TRACE("%p %04x %p\n", iface, lcid, pbstrRfc1766);
2815     if (!pbstrRfc1766)
2816         return E_INVALIDARG;
2817
2818     if (!lcid_to_rfc1766W( lcid, buf, MAX_RFC1766_NAME ))
2819     {
2820         *pbstrRfc1766 = SysAllocString( buf );
2821         return S_OK;
2822     }
2823     return E_FAIL;
2824 }
2825
2826 static HRESULT WINAPI fnIMultiLanguage2_GetLcidFromRfc1766(
2827     IMultiLanguage3* iface,
2828     LCID* pLocale,
2829     BSTR bstrRfc1766)
2830 {
2831     HRESULT hr;
2832     IEnumRfc1766 *rfc1766;
2833
2834     TRACE("%p %p %s\n", iface, pLocale, debugstr_w(bstrRfc1766));
2835
2836     if (!pLocale || !bstrRfc1766)
2837         return E_INVALIDARG;
2838
2839     hr = IMultiLanguage3_EnumRfc1766(iface, 0, &rfc1766);
2840     if (FAILED(hr))
2841         return hr;
2842
2843     hr = lcid_from_rfc1766(rfc1766, pLocale, bstrRfc1766);
2844
2845     IEnumRfc1766_Release(rfc1766);
2846     return hr;
2847 }
2848
2849 static HRESULT WINAPI fnIMultiLanguage2_EnumRfc1766(
2850     IMultiLanguage3* iface,
2851     LANGID LangId,
2852     IEnumRfc1766** ppEnumRfc1766)
2853 {
2854     MLang_impl *This = impl_from_IMultiLanguage3( iface );
2855
2856     TRACE("%p %p\n", This, ppEnumRfc1766);
2857
2858     return EnumRfc1766_create(LangId, ppEnumRfc1766);
2859 }
2860
2861 static HRESULT WINAPI fnIMultiLanguage2_GetRfc1766Info(
2862     IMultiLanguage3* iface,
2863     LCID Locale,
2864     LANGID LangId,
2865     PRFC1766INFO pRfc1766Info)
2866 {
2867     static LANGID last_lang = -1;
2868     LCTYPE type = LOCALE_SLANGUAGE;
2869
2870     TRACE("(%p, 0x%04x, 0x%04x, %p)\n", iface, Locale, LangId, pRfc1766Info);
2871
2872     if (!pRfc1766Info)
2873         return E_INVALIDARG;
2874
2875     if ((PRIMARYLANGID(Locale) == LANG_ENGLISH) ||
2876         (PRIMARYLANGID(Locale) == LANG_CHINESE) ||
2877         (PRIMARYLANGID(Locale) == LANG_ARABIC)) {
2878
2879         if (!SUBLANGID(Locale))
2880             type = LOCALE_SENGLANGUAGE; /* suppress country */
2881     }
2882     else
2883     {
2884         if (!SUBLANGID(Locale)) {
2885             TRACE("SUBLANGID missing in 0x%04x\n", Locale);
2886             return E_FAIL;
2887         }
2888     }
2889
2890     pRfc1766Info->lcid = Locale;
2891     pRfc1766Info->wszRfc1766[0] = 0;
2892     pRfc1766Info->wszLocaleName[0] = 0;
2893
2894     if ((PRIMARYLANGID(LangId) != LANG_ENGLISH) &&
2895         (last_lang != LangId)) {
2896         FIXME("Only English names supported (requested: 0x%04x)\n", LangId);
2897         last_lang = LangId;
2898     }
2899
2900     if ((!lcid_to_rfc1766W(Locale, pRfc1766Info->wszRfc1766, MAX_RFC1766_NAME)) &&
2901         (GetLocaleInfoW(Locale, type, pRfc1766Info->wszLocaleName, MAX_LOCALE_NAME) > 0))
2902             return S_OK;
2903
2904     /* Locale not supported */
2905     return E_INVALIDARG;
2906 }
2907
2908 static HRESULT WINAPI fnIMultiLanguage2_CreateConvertCharset(
2909     IMultiLanguage3* iface,
2910     UINT src_cp,
2911     UINT dst_cp,
2912     DWORD prop,
2913     IMLangConvertCharset** convert_charset)
2914 {
2915     HRESULT hr;
2916
2917     TRACE("(%u %u 0x%08x %p)\n", src_cp, dst_cp, prop, convert_charset);
2918
2919     hr = MLangConvertCharset_create(NULL, (void**)convert_charset);
2920     if (FAILED(hr)) return hr;
2921
2922     return IMLangConvertCharset_Initialize(*convert_charset, src_cp, dst_cp, prop);
2923 }
2924
2925 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringInIStream(
2926     IMultiLanguage3* iface,
2927     DWORD* pdwMode,
2928     DWORD dwFlag,
2929     WCHAR* lpFallBack,
2930     DWORD dwSrcEncoding,
2931     DWORD dwDstEncoding,
2932     IStream* pstmIn,
2933     IStream* pstmOut)
2934 {
2935     char *src, *dst = NULL;
2936     INT srclen, dstlen;
2937     STATSTG stat;
2938     HRESULT hr;
2939
2940     TRACE("%p %0x8 %s %u %u %p %p\n",
2941           pdwMode, dwFlag, debugstr_w(lpFallBack), dwSrcEncoding, dwDstEncoding, pstmIn, pstmOut);
2942
2943     FIXME("dwFlag and lpFallBack not handled\n");
2944
2945     hr = IStream_Stat(pstmIn, &stat, STATFLAG_NONAME);
2946     if (FAILED(hr)) return hr;
2947
2948     if (stat.cbSize.QuadPart > MAXLONG) return E_INVALIDARG;
2949     if (!(src = HeapAlloc(GetProcessHeap(), 0, stat.cbSize.QuadPart))) return E_OUTOFMEMORY;
2950
2951     hr = IStream_Read(pstmIn, src, stat.cbSize.QuadPart, (ULONG *)&srclen);
2952     if (FAILED(hr)) goto exit;
2953
2954     hr = ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding, src, &srclen, NULL, &dstlen);
2955     if (FAILED(hr)) goto exit;
2956
2957     if (!(dst = HeapAlloc(GetProcessHeap(), 0, dstlen)))
2958     {
2959         hr = E_OUTOFMEMORY;
2960         goto exit;
2961     }
2962     hr = ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding, src, &srclen, dst, &dstlen);
2963     if (FAILED(hr)) goto exit;
2964
2965     hr = IStream_Write(pstmOut, dst, dstlen, NULL);
2966
2967 exit:
2968     HeapFree(GetProcessHeap(), 0, src);
2969     HeapFree(GetProcessHeap(), 0, dst);
2970     return hr;
2971 }
2972
2973 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicodeEx(
2974     IMultiLanguage3* iface,
2975     DWORD* pdwMode,
2976     DWORD dwEncoding,
2977     CHAR* pSrcStr,
2978     UINT* pcSrcSize,
2979     WCHAR* pDstStr,
2980     UINT* pcDstSize,
2981     DWORD dwFlag,
2982     WCHAR* lpFallBack)
2983 {
2984     if (dwFlag || lpFallBack)
2985         FIXME("Ignoring dwFlag (0x%x/%d) and lpFallBack (%p)\n",
2986                 dwFlag, dwFlag, lpFallBack);
2987
2988     return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
2989         pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
2990 }
2991
2992 /*****************************************************************************
2993  * MultiLanguage2::ConvertStringToUnicodeEx
2994  *
2995  * Translates the multibyte string from the specified code page to Unicode.
2996  *
2997  * PARAMS
2998  *   see ConvertStringToUnicode
2999  *   dwFlag
3000  *   lpFallBack if dwFlag contains MLCONVCHARF_USEDEFCHAR, lpFallBack string used
3001  *              instead unconvertible characters.
3002  *
3003  * RETURNS
3004  *   S_OK     Success.
3005  *   S_FALSE  The conversion is not supported.
3006  *   E_FAIL   Some error has occurred.
3007  *
3008  * TODO: handle dwFlag and lpFallBack
3009 */
3010 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringFromUnicodeEx(
3011     IMultiLanguage3* This,
3012     DWORD* pdwMode,
3013     DWORD dwEncoding,
3014     WCHAR* pSrcStr,
3015     UINT* pcSrcSize,
3016     CHAR* pDstStr,
3017     UINT* pcDstSize,
3018     DWORD dwFlag,
3019     WCHAR* lpFallBack)
3020 {
3021     FIXME("\n");
3022     return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
3023         pSrcStr, (LPINT)pcSrcSize, pDstStr, (LPINT)pcDstSize);
3024 }
3025
3026 static HRESULT WINAPI fnIMultiLanguage2_DetectCodepageInIStream(
3027     IMultiLanguage3* iface,
3028     DWORD dwFlag,
3029     DWORD dwPrefWinCodePage,
3030     IStream* pstmIn,
3031     DetectEncodingInfo* lpEncoding,
3032     INT* pnScores)
3033 {
3034     FIXME("\n");
3035     return E_NOTIMPL;
3036 }
3037
3038 static HRESULT WINAPI fnIMultiLanguage2_DetectInputCodepage(
3039     IMultiLanguage3* iface,
3040     DWORD dwFlag,
3041     DWORD dwPrefWinCodePage,
3042     CHAR* pSrcStr,
3043     INT* pcSrcSize,
3044     DetectEncodingInfo* lpEncoding,
3045     INT* pnScores)
3046 {
3047     FIXME("\n");
3048     return E_NOTIMPL;
3049 }
3050
3051 static HRESULT WINAPI fnIMultiLanguage2_ValidateCodePage(
3052     IMultiLanguage3* iface,
3053     UINT uiCodePage,
3054     HWND hwnd)
3055 {
3056     return IMultiLanguage3_ValidateCodePageEx(iface,uiCodePage,hwnd,0);
3057 }
3058
3059 static HRESULT WINAPI fnIMultiLanguage2_GetCodePageDescription(
3060     IMultiLanguage3* iface,
3061     UINT uiCodePage,
3062     LCID lcid,
3063     LPWSTR lpWideCharStr,
3064     int cchWideChar)
3065 {
3066     /* Find first instance */
3067     unsigned int i,n;
3068
3069     TRACE ("%u, %04x, %p, %d\n", uiCodePage, lcid, lpWideCharStr, cchWideChar);
3070     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
3071     {
3072         for (n = 0; n < mlang_data[i].number_of_cp; n++)
3073         {
3074             if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
3075             {
3076                 MultiByteToWideChar(CP_ACP, 0,
3077                                     mlang_data[i].mime_cp_info[n].description,
3078                                     -1, lpWideCharStr, cchWideChar);
3079                 return S_OK;
3080             }
3081         }
3082     }
3083
3084     return S_FALSE;
3085 }
3086
3087 static HRESULT WINAPI fnIMultiLanguage2_IsCodePageInstallable(
3088     IMultiLanguage3* iface,
3089     UINT uiCodePage)
3090 {
3091     TRACE("%u\n", uiCodePage);
3092
3093     /* FIXME: the installable set is usually larger than the set of valid codepages */
3094     return IMultiLanguage3_ValidateCodePageEx(iface, uiCodePage, NULL, CPIOD_PEEK);
3095 }
3096
3097 static HRESULT WINAPI fnIMultiLanguage2_SetMimeDBSource(
3098     IMultiLanguage3* iface,
3099     MIMECONTF dwSource)
3100 {
3101     FIXME("0x%08x\n", dwSource);
3102     return S_OK;
3103 }
3104
3105 static HRESULT WINAPI fnIMultiLanguage2_GetNumberOfScripts(
3106     IMultiLanguage3* iface,
3107     UINT* pnScripts)
3108 {
3109     MLang_impl *This = impl_from_IMultiLanguage3( iface );
3110
3111     TRACE("%p %p\n", This, pnScripts);
3112
3113     if (!pnScripts) return S_FALSE;
3114
3115     *pnScripts = This->total_scripts;
3116     return S_OK;
3117 }
3118
3119 static HRESULT WINAPI fnIMultiLanguage2_EnumScripts(
3120     IMultiLanguage3* iface,
3121     DWORD dwFlags,
3122     LANGID LangId,
3123     IEnumScript** ppEnumScript)
3124 {
3125     MLang_impl *This = impl_from_IMultiLanguage3( iface );
3126
3127     TRACE("%p %08x %04x %p\n", This, dwFlags, LangId, ppEnumScript);
3128
3129     return EnumScript_create( This, dwFlags, LangId, ppEnumScript );
3130 }
3131
3132 static HRESULT WINAPI fnIMultiLanguage2_ValidateCodePageEx(
3133     IMultiLanguage3* iface,
3134     UINT uiCodePage,
3135     HWND hwnd,
3136     DWORD dwfIODControl)
3137 {
3138     int i;
3139     MLang_impl *This = impl_from_IMultiLanguage3( iface );
3140
3141     TRACE("%p %u %p %08x\n", This, uiCodePage, hwnd, dwfIODControl);
3142
3143     /* quick check for kernel32 supported code pages */
3144     if (IsValidCodePage(uiCodePage))
3145         return S_OK;
3146
3147     /* check for mlang supported code pages */
3148     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
3149     {
3150         int n;
3151         for (n = 0; n < mlang_data[i].number_of_cp; n++)
3152         {
3153             if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
3154                 return S_OK;
3155         }
3156     }
3157
3158     if (dwfIODControl != CPIOD_PEEK)
3159         FIXME("Request to install codepage language pack not handled\n");
3160
3161     return S_FALSE;
3162 }
3163
3164 static HRESULT WINAPI fnIMultiLanguage3_DetectOutboundCodePage(
3165     IMultiLanguage3 *iface,
3166     DWORD dwFlags,
3167     LPCWSTR lpWideCharStr,
3168     UINT cchWideChar,
3169     UINT *puiPreferredCodePages,
3170     UINT nPreferredCodePages,
3171     UINT *puiDetectedCodePages,
3172     UINT *pnDetectedCodePages,
3173     WCHAR *lpSpecialChar)
3174 {
3175     MLang_impl *This = impl_from_IMultiLanguage3( iface );
3176
3177     FIXME("(%p)->(%08x %s %u %p %u %p %p %p)\n", This, dwFlags, debugstr_w(lpWideCharStr),
3178           cchWideChar, puiPreferredCodePages, nPreferredCodePages, puiDetectedCodePages,
3179           pnDetectedCodePages, lpSpecialChar);
3180     return E_NOTIMPL;
3181 }
3182
3183 static HRESULT WINAPI fnIMultiLanguage3_DetectOutboundCodePageInIStream(
3184     IMultiLanguage3 *iface,
3185     DWORD dwFlags,
3186     IStream *pStrIn,
3187     UINT *puiPreferredCodePages,
3188     UINT nPreferredCodePages,
3189     UINT *puiDetectedCodePages,
3190     UINT *pnDetectedCodePages,
3191     WCHAR *lpSpecialChar)
3192 {
3193     MLang_impl *This = impl_from_IMultiLanguage3( iface );
3194
3195     FIXME("(%p)->(%08x %p %p %u %p %p %p)\n", This, dwFlags, pStrIn,
3196           puiPreferredCodePages, nPreferredCodePages, puiDetectedCodePages,
3197           pnDetectedCodePages, lpSpecialChar);
3198     return E_NOTIMPL;
3199 }
3200
3201 static const IMultiLanguage3Vtbl IMultiLanguage3_vtbl =
3202 {
3203     fnIMultiLanguage2_QueryInterface,
3204     fnIMultiLanguage2_AddRef,
3205     fnIMultiLanguage2_Release,
3206     fnIMultiLanguage2_GetNumberOfCodePageInfo,
3207     fnIMultiLanguage2_GetCodePageInfo,
3208     fnIMultiLanguage2_GetFamilyCodePage,
3209     fnIMultiLanguage2_EnumCodePages,
3210     fnIMultiLanguage2_GetCharsetInfo,
3211     fnIMultiLanguage2_IsConvertible,
3212     fnIMultiLanguage2_ConvertString,
3213     fnIMultiLanguage2_ConvertStringToUnicode,
3214     fnIMultiLanguage2_ConvertStringFromUnicode,
3215     fnIMultiLanguage2_ConvertStringReset,
3216     fnIMultiLanguage2_GetRfc1766FromLcid,
3217     fnIMultiLanguage2_GetLcidFromRfc1766,
3218     fnIMultiLanguage2_EnumRfc1766,
3219     fnIMultiLanguage2_GetRfc1766Info,
3220     fnIMultiLanguage2_CreateConvertCharset,
3221     fnIMultiLanguage2_ConvertStringInIStream,
3222     fnIMultiLanguage2_ConvertStringToUnicodeEx,
3223     fnIMultiLanguage2_ConvertStringFromUnicodeEx,
3224     fnIMultiLanguage2_DetectCodepageInIStream,
3225     fnIMultiLanguage2_DetectInputCodepage,
3226     fnIMultiLanguage2_ValidateCodePage,
3227     fnIMultiLanguage2_GetCodePageDescription,
3228     fnIMultiLanguage2_IsCodePageInstallable,
3229     fnIMultiLanguage2_SetMimeDBSource,
3230     fnIMultiLanguage2_GetNumberOfScripts,
3231     fnIMultiLanguage2_EnumScripts,
3232     fnIMultiLanguage2_ValidateCodePageEx,
3233     fnIMultiLanguage3_DetectOutboundCodePage,
3234     fnIMultiLanguage3_DetectOutboundCodePageInIStream
3235 };
3236
3237 /******************************************************************************/
3238
3239 static inline MLang_impl *impl_from_IMLangFontLink2( IMLangFontLink2 *iface )
3240 {
3241     return CONTAINING_RECORD( iface, MLang_impl, IMLangFontLink2_iface );
3242 }
3243
3244 static HRESULT WINAPI fnIMLangFontLink2_QueryInterface(
3245     IMLangFontLink2 * iface,
3246     REFIID riid,
3247     void** ppvObject)
3248 {
3249     MLang_impl *This = impl_from_IMLangFontLink2( iface );
3250     return IMultiLanguage3_QueryInterface( &This->IMultiLanguage3_iface, riid, ppvObject );
3251 }
3252
3253 static ULONG WINAPI fnIMLangFontLink2_AddRef( IMLangFontLink2* iface )
3254 {
3255     MLang_impl *This = impl_from_IMLangFontLink2( iface );
3256     return IMultiLanguage3_AddRef( &This->IMultiLanguage3_iface );
3257 }
3258
3259 static ULONG WINAPI fnIMLangFontLink2_Release( IMLangFontLink2* iface )
3260 {
3261     MLang_impl *This = impl_from_IMLangFontLink2( iface );
3262     return IMultiLanguage3_Release( &This->IMultiLanguage3_iface );
3263 }
3264
3265 static HRESULT WINAPI fnIMLangFontLink2_GetCharCodePages( IMLangFontLink2* This,
3266         WCHAR chSrc, DWORD *pdwCodePages)
3267 {
3268     FIXME("(%p)->%s %p\n",This, debugstr_wn(&chSrc,1),pdwCodePages);
3269     return E_NOTIMPL;
3270 }
3271
3272 static HRESULT WINAPI fnIMLangFontLink2_GetStrCodePages( IMLangFontLink2* This,
3273         const WCHAR *pszSrc, LONG cchSrc, DWORD dwPriorityCodePages,
3274         DWORD *pdwCodePages, LONG *pcchCodePages)
3275 {
3276     return fnIMLangFontLink_GetStrCodePages((IMLangFontLink *)This,
3277             pszSrc, cchSrc, dwPriorityCodePages, pdwCodePages, pcchCodePages);
3278 }
3279
3280 static HRESULT WINAPI fnIMLangFontLink2_CodePageToCodePages(IMLangFontLink2* This,
3281         UINT uCodePage,
3282         DWORD *pdwCodePages)
3283 {
3284     FIXME("(%p)->%i %p\n",This, uCodePage, pdwCodePages);
3285     return E_NOTIMPL;
3286 }
3287
3288 static HRESULT WINAPI fnIMLangFontLink2_CodePagesToCodePage(IMLangFontLink2* This,
3289         DWORD dwCodePages, UINT uDefaultCodePage, UINT *puCodePage)
3290 {
3291     FIXME("(%p)->%i %i %p\n",This, dwCodePages, uDefaultCodePage, puCodePage);
3292     return E_NOTIMPL;
3293 }
3294
3295 static HRESULT WINAPI fnIMLangFontLink2_GetFontCodePages(IMLangFontLink2* This,
3296         HDC hDC, HFONT hFont, DWORD *pdwCodePages)
3297 {
3298     FIXME("(%p)->%p %p %p\n",This, hDC, hFont, pdwCodePages);
3299     return E_NOTIMPL;
3300 }
3301
3302 static HRESULT WINAPI fnIMLangFontLink2_ReleaseFont(IMLangFontLink2* This,
3303         HFONT hFont)
3304 {
3305     FIXME("(%p)->%p\n",This, hFont);
3306     return E_NOTIMPL;
3307 }
3308
3309 static HRESULT WINAPI fnIMLangFontLink2_ResetFontMapping(IMLangFontLink2* This)
3310 {
3311     FIXME("(%p)->\n",This);
3312     return E_NOTIMPL;
3313 }
3314
3315 static HRESULT WINAPI fnIMLangFontLink2_MapFont(IMLangFontLink2* This,
3316         HDC hDC, DWORD dwCodePages, WCHAR chSrc, HFONT *pFont)
3317 {
3318     FIXME("(%p)->%p %i %s %p\n",This, hDC, dwCodePages, debugstr_wn(&chSrc,1), pFont);
3319     return E_NOTIMPL;
3320 }
3321
3322 static HRESULT WINAPI fnIMLangFontLink2_GetFontUnicodeRanges(IMLangFontLink2* This,
3323         HDC hDC, UINT *puiRanges, UNICODERANGE *pUranges)
3324 {
3325     DWORD size;
3326     GLYPHSET *gs;
3327
3328     TRACE("(%p)->%p %p %p\n", This, hDC, puiRanges, pUranges);
3329
3330     if (!puiRanges) return E_INVALIDARG;
3331     if (!(size = GetFontUnicodeRanges(hDC, NULL))) return E_FAIL;
3332     if (!(gs = HeapAlloc(GetProcessHeap(), 0, size))) return E_OUTOFMEMORY;
3333
3334     GetFontUnicodeRanges(hDC, gs);
3335     *puiRanges = gs->cRanges;
3336     if (pUranges)
3337     {
3338         UINT i;
3339         for (i = 0; i < gs->cRanges; i++)
3340         {
3341             if (i >= *puiRanges) break;
3342             pUranges[i].wcFrom = gs->ranges[i].wcLow;
3343             pUranges[i].wcTo   = gs->ranges[i].wcLow + gs->ranges[i].cGlyphs;
3344         }
3345         *puiRanges = i;
3346     }
3347     HeapFree(GetProcessHeap(), 0, gs);
3348     return S_OK;
3349 }
3350
3351 static HRESULT WINAPI fnIMLangFontLink2_GetScriptFontInfo(IMLangFontLink2* This,
3352         SCRIPT_ID sid, DWORD dwFlags, UINT *puiFonts,
3353         SCRIPTFONTINFO *pScriptFont)
3354 {
3355     UINT i, j;
3356
3357     TRACE("(%p)->%u %x %p %p\n", This, sid, dwFlags, puiFonts, pScriptFont);
3358
3359     if (!dwFlags) dwFlags = SCRIPTCONTF_PROPORTIONAL_FONT;
3360
3361     for (i = 0, j = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
3362     {
3363         if (sid == mlang_data[i].sid)
3364         {
3365             if (pScriptFont)
3366             {
3367                 if (j >= *puiFonts) break;
3368
3369                 pScriptFont[j].scripts = 1 << mlang_data[i].sid;
3370                 if (dwFlags == SCRIPTCONTF_FIXED_FONT)
3371                 {
3372                     MultiByteToWideChar(CP_ACP, 0, mlang_data[i].fixed_font, -1,
3373                         pScriptFont[j].wszFont, MAX_MIMEFACE_NAME);
3374                 }
3375                 else if (dwFlags == SCRIPTCONTF_PROPORTIONAL_FONT)
3376                 {
3377                     MultiByteToWideChar(CP_ACP, 0, mlang_data[i].proportional_font, -1,
3378                         pScriptFont[j].wszFont, MAX_MIMEFACE_NAME);
3379                 }
3380             }
3381             j++;
3382         }
3383     }
3384     *puiFonts = j;
3385     return S_OK;
3386 }
3387
3388 static HRESULT WINAPI fnIMLangFontLink2_CodePageToScriptID(IMLangFontLink2* This,
3389         UINT uiCodePage, SCRIPT_ID *pSid)
3390 {
3391     UINT i;
3392
3393     TRACE("(%p)->%i %p\n", This, uiCodePage, pSid);
3394
3395     if (uiCodePage == CP_UNICODE) return E_FAIL;
3396
3397     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
3398     {
3399         if (uiCodePage == mlang_data[i].family_codepage)
3400         {
3401             if (pSid) *pSid = mlang_data[i].sid;
3402             return S_OK;
3403         }
3404     }
3405     return E_FAIL;
3406 }
3407
3408 static const IMLangFontLink2Vtbl IMLangFontLink2_vtbl =
3409 {
3410     fnIMLangFontLink2_QueryInterface,
3411     fnIMLangFontLink2_AddRef,
3412     fnIMLangFontLink2_Release,
3413     fnIMLangFontLink2_GetCharCodePages,
3414     fnIMLangFontLink2_GetStrCodePages,
3415     fnIMLangFontLink2_CodePageToCodePages,
3416     fnIMLangFontLink2_CodePagesToCodePage,
3417     fnIMLangFontLink2_GetFontCodePages,
3418     fnIMLangFontLink2_ReleaseFont,
3419     fnIMLangFontLink2_ResetFontMapping,
3420     fnIMLangFontLink2_MapFont,
3421     fnIMLangFontLink2_GetFontUnicodeRanges,
3422     fnIMLangFontLink2_GetScriptFontInfo,
3423     fnIMLangFontLink2_CodePageToScriptID
3424 };
3425
3426 /******************************************************************************/
3427
3428 static inline MLang_impl *impl_from_IMLangLineBreakConsole( IMLangLineBreakConsole *iface )
3429 {
3430     return CONTAINING_RECORD( iface, MLang_impl, IMLangLineBreakConsole_iface );
3431 }
3432
3433 static HRESULT WINAPI fnIMLangLineBreakConsole_QueryInterface(
3434     IMLangLineBreakConsole* iface,
3435     REFIID riid,
3436     void** ppvObject)
3437 {
3438     MLang_impl *This = impl_from_IMLangLineBreakConsole( iface );
3439     return IMultiLanguage3_QueryInterface( &This->IMultiLanguage3_iface, riid, ppvObject );
3440 }
3441
3442 static ULONG WINAPI fnIMLangLineBreakConsole_AddRef(
3443     IMLangLineBreakConsole* iface )
3444 {
3445     MLang_impl *This = impl_from_IMLangLineBreakConsole( iface );
3446     return IMultiLanguage3_AddRef( &This->IMultiLanguage3_iface );
3447 }
3448
3449 static ULONG WINAPI fnIMLangLineBreakConsole_Release(
3450     IMLangLineBreakConsole* iface )
3451 {
3452     MLang_impl *This = impl_from_IMLangLineBreakConsole( iface );
3453     return IMultiLanguage3_Release( &This->IMultiLanguage3_iface );
3454 }
3455
3456 static HRESULT WINAPI fnIMLangLineBreakConsole_BreakLineML(
3457     IMLangLineBreakConsole* iface,
3458     IMLangString* pSrcMLStr,
3459     LONG lSrcPos,
3460     LONG lSrcLen,
3461     LONG cMinColumns,
3462     LONG cMaxColumns,
3463     LONG* plLineLen,
3464     LONG* plSkipLen)
3465 {
3466     FIXME("(%p)->%p %i %i %i %i %p %p\n", iface, pSrcMLStr, lSrcPos, lSrcLen, cMinColumns, cMaxColumns, plLineLen, plSkipLen);
3467     return E_NOTIMPL;
3468 }
3469
3470 static HRESULT WINAPI fnIMLangLineBreakConsole_BreakLineW(
3471     IMLangLineBreakConsole* iface,
3472     LCID locale,
3473     const WCHAR* pszSrc,
3474     LONG cchSrc,
3475     LONG cMaxColumns,
3476     LONG* pcchLine,
3477     LONG* pcchSkip )
3478 {
3479     FIXME("(%p)->%i %s %i %i %p %p\n", iface, locale, debugstr_wn(pszSrc,cchSrc), cchSrc, cMaxColumns, pcchLine, pcchSkip);
3480
3481     *pcchLine = cchSrc;
3482     *pcchSkip = 0;
3483     return S_OK;
3484 }
3485
3486 static HRESULT WINAPI fnIMLangLineBreakConsole_BreakLineA(
3487     IMLangLineBreakConsole* iface,
3488     LCID locale,
3489     UINT uCodePage,
3490     const CHAR* pszSrc,
3491     LONG cchSrc,
3492     LONG cMaxColumns,
3493     LONG* pcchLine,
3494     LONG* pcchSkip)
3495 {
3496     FIXME("(%p)->%i %i %s %i %i %p %p\n", iface, locale, uCodePage, debugstr_an(pszSrc,cchSrc), cchSrc, cMaxColumns, pcchLine, pcchSkip);
3497
3498     *pcchLine = cchSrc;
3499     *pcchSkip = 0;
3500     return S_OK;
3501 }
3502
3503 static const IMLangLineBreakConsoleVtbl IMLangLineBreakConsole_vtbl =
3504 {
3505     fnIMLangLineBreakConsole_QueryInterface,
3506     fnIMLangLineBreakConsole_AddRef,
3507     fnIMLangLineBreakConsole_Release,
3508     fnIMLangLineBreakConsole_BreakLineML,
3509     fnIMLangLineBreakConsole_BreakLineW,
3510     fnIMLangLineBreakConsole_BreakLineA
3511 };
3512
3513 struct convert_charset {
3514     IMLangConvertCharset IMLangConvertCharset_iface;
3515     LONG ref;
3516
3517     UINT src_cp;
3518     UINT dst_cp;
3519 };
3520
3521 static inline struct convert_charset *impl_from_IMLangConvertCharset(IMLangConvertCharset *iface)
3522 {
3523     return CONTAINING_RECORD(iface, struct convert_charset, IMLangConvertCharset_iface);
3524 }
3525
3526 static HRESULT WINAPI MLangConvertCharset_QueryInterface(IMLangConvertCharset *iface, REFIID riid, void **obj)
3527 {
3528     struct convert_charset *This = impl_from_IMLangConvertCharset(iface);
3529
3530     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
3531
3532     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IMLangConvertCharset))
3533     {
3534         *obj = &This->IMLangConvertCharset_iface;
3535         IMLangConvertCharset_AddRef(iface);
3536         return S_OK;
3537     }
3538
3539     *obj = NULL;
3540     return E_NOINTERFACE;
3541 }
3542
3543 static ULONG WINAPI MLangConvertCharset_AddRef(IMLangConvertCharset *iface)
3544 {
3545     struct convert_charset *This = impl_from_IMLangConvertCharset(iface);
3546     ULONG ref = InterlockedIncrement(&This->ref);
3547     TRACE("(%p)->(%u)\n", This, ref);
3548     return ref;
3549 }
3550
3551 static ULONG WINAPI MLangConvertCharset_Release(IMLangConvertCharset *iface)
3552 {
3553     struct convert_charset *This = impl_from_IMLangConvertCharset(iface);
3554     ULONG ref = InterlockedDecrement(&This->ref);
3555
3556     TRACE("(%p)->(%u)\n", This, ref);
3557     if (!ref)
3558     {
3559         HeapFree(GetProcessHeap(), 0, This);
3560         UnlockModule();
3561     }
3562
3563     return ref;
3564 }
3565
3566 static HRESULT WINAPI MLangConvertCharset_Initialize(IMLangConvertCharset *iface,
3567     UINT src_cp, UINT dst_cp, DWORD prop)
3568 {
3569     struct convert_charset *This = impl_from_IMLangConvertCharset(iface);
3570
3571     TRACE("(%p)->(%u %u 0x%08x)\n", This, src_cp, dst_cp, prop);
3572
3573     prop &= ~MLCONVCHARF_USEDEFCHAR;
3574     if (prop)
3575         FIXME("property 0x%08x not supported\n", prop);
3576
3577     This->src_cp = src_cp;
3578     This->dst_cp = dst_cp;
3579
3580     return S_OK;
3581 }
3582
3583 static HRESULT WINAPI MLangConvertCharset_GetSourceCodePage(IMLangConvertCharset *iface, UINT *src_cp)
3584 {
3585     struct convert_charset *This = impl_from_IMLangConvertCharset(iface);
3586
3587     TRACE("(%p)->(%p)\n", This, src_cp);
3588
3589     if (!src_cp) return E_INVALIDARG;
3590     *src_cp = This->src_cp;
3591     return S_OK;
3592 }
3593
3594 static HRESULT WINAPI MLangConvertCharset_GetDestinationCodePage(IMLangConvertCharset *iface, UINT *dst_cp)
3595 {
3596     struct convert_charset *This = impl_from_IMLangConvertCharset(iface);
3597
3598     TRACE("(%p)->(%p)\n", This, dst_cp);
3599
3600     if (!dst_cp) return E_INVALIDARG;
3601     *dst_cp = This->dst_cp;
3602     return S_OK;
3603 }
3604
3605 static HRESULT WINAPI MLangConvertCharset_GetProperty(IMLangConvertCharset *iface, DWORD *prop)
3606 {
3607     struct convert_charset *This = impl_from_IMLangConvertCharset(iface);
3608     FIXME("(%p)->(%p): stub\n", This, prop);
3609     return E_NOTIMPL;
3610 }
3611
3612 static HRESULT WINAPI MLangConvertCharset_DoConversion(IMLangConvertCharset *iface, BYTE *src,
3613     UINT *src_size, BYTE *dest, UINT *dest_size)
3614 {
3615     struct convert_charset *This = impl_from_IMLangConvertCharset(iface);
3616     FIXME("(%p)->(%p %p %p %p): stub\n", This, src, src_size, dest, dest_size);
3617     return E_NOTIMPL;
3618 }
3619
3620 static HRESULT WINAPI MLangConvertCharset_DoConversionToUnicode(IMLangConvertCharset *iface, CHAR *src,
3621     UINT *src_size, WCHAR *dest, UINT *dest_size)
3622 {
3623     struct convert_charset *This = impl_from_IMLangConvertCharset(iface);
3624     TRACE("(%p)->(%p %p %p %p)\n", This, src, src_size, dest, dest_size);
3625     return ConvertINetMultiByteToUnicode(NULL, This->src_cp, src, (INT*)src_size, dest, (INT*)dest_size);
3626 }
3627
3628 static HRESULT WINAPI MLangConvertCharset_DoConversionFromUnicode(IMLangConvertCharset *iface,
3629     WCHAR *src, UINT *src_size, CHAR *dest, UINT *dest_size)
3630 {
3631     struct convert_charset *This = impl_from_IMLangConvertCharset(iface);
3632     TRACE("(%p)->(%p %p %p %p)\n", This, src, src_size, dest, dest_size);
3633     return ConvertINetUnicodeToMultiByte(NULL, This->dst_cp, src, (INT*)src_size, dest, (INT*)dest_size);
3634 }
3635
3636 static const IMLangConvertCharsetVtbl MLangConvertCharsetVtbl =
3637 {
3638     MLangConvertCharset_QueryInterface,
3639     MLangConvertCharset_AddRef,
3640     MLangConvertCharset_Release,
3641     MLangConvertCharset_Initialize,
3642     MLangConvertCharset_GetSourceCodePage,
3643     MLangConvertCharset_GetDestinationCodePage,
3644     MLangConvertCharset_GetProperty,
3645     MLangConvertCharset_DoConversion,
3646     MLangConvertCharset_DoConversionToUnicode,
3647     MLangConvertCharset_DoConversionFromUnicode
3648 };
3649
3650 static HRESULT MultiLanguage_create(IUnknown *pUnkOuter, LPVOID *ppObj)
3651 {
3652     MLang_impl *mlang;
3653     UINT i;
3654
3655     TRACE("Creating MultiLanguage object\n");
3656
3657     if( pUnkOuter )
3658         return CLASS_E_NOAGGREGATION;
3659
3660     mlang = HeapAlloc( GetProcessHeap(), 0, sizeof (MLang_impl) );
3661     mlang->IMLangFontLink_iface.lpVtbl = &IMLangFontLink_vtbl;
3662     mlang->IMultiLanguage_iface.lpVtbl = &IMultiLanguage_vtbl;
3663     mlang->IMultiLanguage3_iface.lpVtbl = &IMultiLanguage3_vtbl;
3664     mlang->IMLangFontLink2_iface.lpVtbl = &IMLangFontLink2_vtbl;
3665     mlang->IMLangLineBreakConsole_iface.lpVtbl = &IMLangLineBreakConsole_vtbl;
3666
3667     mlang->total_cp = 0;
3668     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
3669         mlang->total_cp += mlang_data[i].number_of_cp;
3670
3671     /* do not enumerate unicode flavours */
3672     mlang->total_scripts = sizeof(mlang_data)/sizeof(mlang_data[0]) - 1;
3673
3674     mlang->ref = 1;
3675     *ppObj = &mlang->IMultiLanguage_iface;
3676     TRACE("returning %p\n", mlang);
3677
3678     LockModule();
3679
3680     return S_OK;
3681 }
3682
3683 static HRESULT MLangConvertCharset_create(IUnknown *outer, void **obj)
3684 {
3685     struct convert_charset *convert;
3686
3687     if (outer)
3688         return CLASS_E_NOAGGREGATION;
3689
3690     *obj = NULL;
3691
3692     convert = HeapAlloc(GetProcessHeap(), 0, sizeof(struct convert_charset));
3693     if (!convert) return E_OUTOFMEMORY;
3694
3695     convert->IMLangConvertCharset_iface.lpVtbl = &MLangConvertCharsetVtbl;
3696     convert->ref = 1;
3697
3698     *obj = &convert->IMLangConvertCharset_iface;
3699
3700     LockModule();
3701
3702     return S_OK;
3703 }
3704
3705 /******************************************************************************/
3706
3707 HRESULT WINAPI DllCanUnloadNow(void)
3708 {
3709     return dll_count == 0 ? S_OK : S_FALSE;
3710 }
3711
3712
3713 /***********************************************************************
3714  *              DllRegisterServer (MLANG.@)
3715  */
3716 HRESULT WINAPI DllRegisterServer(void)
3717 {
3718     return __wine_register_resources( instance );
3719 }
3720
3721 /***********************************************************************
3722  *              DllUnregisterServer (MLANG.@)
3723  */
3724 HRESULT WINAPI DllUnregisterServer(void)
3725 {
3726     return __wine_unregister_resources( instance );
3727 }
3728
3729 HRESULT WINAPI GetGlobalFontLinkObject(void **unknown)
3730 {
3731     if (!unknown) return E_INVALIDARG;
3732
3733     FIXME("%p: stub\n", unknown);
3734
3735     return S_FALSE;
3736 }