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 Dmitry Timoshkov
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27
  28 #define COBJMACROS
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wingdi.h"
  33 #include "winuser.h"
  34 #include "winreg.h"
  35 #include "ole2.h"
  36 #include "mlang.h"
  37
  38 #include "uuids.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 #define ICOM_THIS_MULTI(impl,field,iface) impl* const This=(impl*)((char*)(iface) - offsetof(impl,field))
  50
  51 static HRESULT MultiLanguage_create(IUnknown *pUnkOuter, LPVOID *ppObj);
  52
  53 /* FIXME:
  54  * Under what circumstances HKEY_CLASSES_ROOT\MIME\Database\Codepage and
  55  * HKEY_CLASSES_ROOT\MIME\Database\Charset are used?
  56  */
  57
  58 typedef struct
  59 {
  60     const char *description;
  61     UINT cp;
  62     DWORD flags;
  63     const char *web_charset;
  64     const char *header_charset;
  65     const char *body_charset;
  66 } MIME_CP_INFO;
  67
  68 /* These data are based on the codepage info in libs/unicode/cpmap.pl */
  69 /* FIXME: Add 28604 (Celtic), 28606 (Balkan) */
  70
  71 static const MIME_CP_INFO arabic_cp[] =
  72 {
  73     { "Arabic (864)",
  74       864, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
  75            MIMECONTF_MIME_LATEST,
  76       "ibm864", "ibm864", "ibm864" },
  77     { "Arabic (1006)",
  78       1006, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
  79             MIMECONTF_MIME_LATEST,
  80       "ibm1006", "ibm1006", "ibm1006" },
  81     { "Arabic (Windows)",
  82       1256, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
  83             MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
  84             MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
  85       "windows-1256", "windows-1256", "windows-1256" },
  86     { "Arabic (ISO)",
  87       28596, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
  88              MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
  89              MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
  90              MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
  91       "iso-8859-6", "iso-8859-6", "iso-8859-6" }
  92 };
  93 static const MIME_CP_INFO baltic_cp[] =
  94 {
  95     { "Baltic (DOS)",
  96       775, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
  97            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
  98       "ibm775", "ibm775", "ibm775" },
  99     { "Baltic (Windows)",
 100       1257, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 101             MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 102             MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
 103             MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 104       "windows-1257", "windows-1257", "windows-1257" },
 105     { "Baltic (ISO)",
 106       28594, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
 107              MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
 108              MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
 109              MIMECONTF_MIME_LATEST,
 110       "iso-8859-4", "iso-8859-4", "iso-8859-4" },
 111     { "Estonian (ISO)",
 112       28603, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 113              MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 114       "iso-8859-13", "iso-8859-13", "iso-8859-13" }
 115 };
 116 static const MIME_CP_INFO chinese_simplified_cp[] =
 117 {
 118     { "Chinese Simplified (GB2312)",
 119       936, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 120            MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 121            MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 122            MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 123       "gb2312", "gb2312", "gb2312" }
 124 };
 125 static const MIME_CP_INFO chinese_traditional_cp[] =
 126 {
 127     { "Chinese Traditional (Big5)",
 128       950, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 129            MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 130            MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
 131            MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 132       "big5", "big5", "big5" }
 133 };
 134 static const MIME_CP_INFO central_european_cp[] =
 135 {
 136     { "Central European (DOS)",
 137       852, MIMECONTF_BROWSER | MIMECONTF_IMPORT | MIMECONTF_SAVABLE_BROWSER |
 138            MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
 139            MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 140       "ibm852", "ibm852", "ibm852" },
 141     { "Central European (Windows)",
 142       1250, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
 143             MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
 144             MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
 145             MIMECONTF_MIME_LATEST,
 146       "windows-1250", "windows-1250", "windows-1250" },
 147     { "Central European (Mac)",
 148       10029, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 149              MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 150       "x-mac-ce", "x-mac-ce", "x-mac-ce" },
 151     { "Central European (ISO)",
 152       28592, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 153              MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 154              MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
 155              MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 156       "iso-8859-2", "iso-8859-2", "iso-8859-2" }
 157 };
 158 static const MIME_CP_INFO cyrillic_cp[] =
 159 {
 160     { "OEM Cyrillic",
 161       855, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 162            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 163       "ibm855", "ibm855", "ibm855" },
 164     { "Cyrillic (DOS)",
 165       866, MIMECONTF_BROWSER | MIMECONTF_IMPORT | MIMECONTF_SAVABLE_BROWSER |
 166            MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 |
 167            MIMECONTF_MIME_LATEST,
 168       "cp866", "cp866", "cp866" },
 169 #if 0 /* Windows has 20866 as an official code page for KOI8-R */
 170     { "Cyrillic (KOI8-R)",
 171       878, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 172            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 173       "koi8-r", "koi8-r", "koi8-r" },
 174 #endif
 175     { "Cyrillic (Windows)",
 176       1251, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
 177             MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
 178             MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 179       "windows-1251", "windows-1251", "windows-1251" },
 180     { "Cyrillic (Mac)",
 181       10007, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 182              MIMECONTF_MIME_LATEST,
 183       "x-mac-cyrillic", "x-mac-cyrillic", "x-mac-cyrillic" },
 184     { "Cyrillic (KOI8-R)",
 185       20866, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 186              MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 187              MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
 188              MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 189       "koi8-r", "koi8-r", "koi8-r" },
 190     { "Cyrillic (KOI8-U)",
 191       21866, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 192              MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 193              MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
 194              MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 195       "koi8-u", "koi8-u", "koi8-u" },
 196     { "Cyrillic (ISO)",
 197       28595, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 198              MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 199              MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
 200              MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 201       "iso-8859-5", "iso-8859-5", "iso-8859-5" }
 202 };
 203 static const MIME_CP_INFO greek_cp[] =
 204 {
 205     { "Greek (DOS)",
 206       737, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 207            MIMECONTF_MIME_LATEST,
 208       "ibm737", "ibm737", "ibm737" },
 209     { "Greek, Modern (DOS)",
 210       869, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 211            MIMECONTF_MIME_LATEST,
 212       "ibm869", "ibm869", "ibm869" },
 213     { "IBM EBCDIC (Greek Modern)",
 214       875, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 215            MIMECONTF_MIME_LATEST,
 216       "cp875", "cp875", "cp875" },
 217     { "Greek (Windows)",
 218       1253, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
 219             MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
 220             MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 221       "windows-1253", "windows-1253", "windows-1253" },
 222     { "Greek (Mac)",
 223       10006, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 224              MIMECONTF_MIME_LATEST,
 225       "x-mac-greek", "x-mac-greek", "x-mac-greek" },
 226     { "Greek (ISO)",
 227       28597, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 228              MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 229              MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
 230              MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 231       "iso-8859-7", "iso-8859-7", "iso-8859-7" }
 232 };
 233 static const MIME_CP_INFO hebrew_cp[] =
 234 {
 235     { "Hebrew (424)",
 236       424, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 237            MIMECONTF_MIME_LATEST,
 238       "ibm424", "ibm424", "ibm424" },
 239     { "Hebrew (856)",
 240       856, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 241            MIMECONTF_MIME_LATEST,
 242       "cp856", "cp856", "cp856" },
 243     { "Hebrew (DOS)",
 244       862, MIMECONTF_BROWSER | MIMECONTF_MINIMAL | MIMECONTF_IMPORT |
 245            MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 246            MIMECONTF_MIME_LATEST,
 247       "dos-862", "dos-862", "dos-862" },
 248     { "Hebrew (Windows)",
 249       1255, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
 250             MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
 251             MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 252       "windows-1255", "windows-1255", "windows-1255" },
 253     { "Hebrew (ISO-Visual)",
 254       28598, MIMECONTF_BROWSER | MIMECONTF_MINIMAL | MIMECONTF_IMPORT |
 255              MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
 256              MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 257       "iso-8859-8", "iso-8859-8", "iso-8859-8" }
 258 };
 259 static const MIME_CP_INFO japanese_cp[] =
 260 {
 261     { "Japanese (Shift-JIS)",
 262       932, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 263            MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 264            MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 265            MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 266       "shift_jis", "iso-2022-jp", "iso-2022-jp" },
 267     { "Japanese (JIS 0208-1990 and 0212-1990)",
 268       20932, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 269              MIMECONTF_MIME_LATEST,
 270       "euc-jp", "euc-jp", "euc-jp" }
 271 };
 272 static const MIME_CP_INFO korean_cp[] =
 273 {
 274     { "Korean",
 275       949, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 276            MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 277            MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID_NLS |
 278            MIMECONTF_MIME_LATEST,
 279       "ks_c_5601-1987", "ks_c_5601-1987", "ks_c_5601-1987" }
 280 };
 281 static const MIME_CP_INFO thai_cp[] =
 282 {
 283     { "Thai (Windows)",
 284       874, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_MIME_LATEST,
 285       "ibm-thai", "ibm-thai", "ibm-thai" }
 286 };
 287 static const MIME_CP_INFO turkish_cp[] =
 288 {
 289     { "Turkish (DOS)",
 290       857, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 291            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 292       "ibm857", "ibm857", "ibm857" },
 293     { "IBM EBCDIC (Turkish Latin-5)",
 294       1026, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 295             MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 296       "ibm1026", "ibm1026", "ibm1026" },
 297     { "Turkish (Windows)",
 298       1254, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 299             MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 300             MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
 301             MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 302       "windows-1254", "windows-1254", "windows-1254" },
 303     { "Turkish (Mac)",
 304       10081, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 305              MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 306       "x-mac-turkish", "x-mac-turkish", "x-mac-turkish" },
 307     { "Latin 3 (ISO)",
 308       28593, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT |
 309              MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_EXPORT | MIMECONTF_VALID |
 310              MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 311       "iso-8859-3", "iso-8859-3", "iso-8859-3" },
 312     { "Turkish (ISO)",
 313       28599, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 314              MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 315              MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
 316              MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 317       "iso-8859-9", "iso-8859-9", "iso-8859-9" }
 318 };
 319 static const MIME_CP_INFO vietnamese_cp[] =
 320 {
 321     { "Vietnamese (Windows)",
 322       1258, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
 323             MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
 324             MIMECONTF_EXPORT | MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 |
 325             MIMECONTF_MIME_LATEST,
 326       "windows-1258", "windows-1258", "windows-1258" }
 327 };
 328 static const MIME_CP_INFO western_cp[] =
 329 {
 330     { "IBM EBCDIC (US-Canada)",
 331       37, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 332           MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 333       "ibm037", "ibm037", "ibm037" },
 334     { "OEM United States",
 335       437, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 336            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 337       "ibm437", "ibm437", "ibm437" },
 338     { "IBM EBCDIC (International)",
 339       500, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 340            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 341       "ibm500", "ibm500", "ibm500" },
 342     { "Western European (DOS)",
 343       850, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 344            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 345       "ibm850", "ibm850", "ibm850" },
 346     { "Portuguese (DOS)",
 347       860, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 348            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 349       "ibm860", "ibm860", "ibm860" },
 350     { "Icelandic (DOS)",
 351       861, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 352            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 353       "ibm861", "ibm861", "ibm861" },
 354     { "French Canadian (DOS)",
 355       863, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 356            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 357       "ibm863", "ibm863", "ibm863" },
 358     { "Nordic (DOS)",
 359       865, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 360            MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 361       "ibm865", "ibm865", "ibm865" },
 362     { "Western European (Windows)",
 363       1252, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_MINIMAL |
 364             MIMECONTF_IMPORT | MIMECONTF_SAVABLE_MAILNEWS |
 365             MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT | MIMECONTF_VALID |
 366             MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 367       "windows-1252", "windows-1252", "iso-8859-1" },
 368     { "Western European (Mac)",
 369       10000, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 370              MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 371       "macintosh", "macintosh", "macintosh" },
 372     { "Icelandic (Mac)",
 373       10079, MIMECONTF_IMPORT | MIMECONTF_EXPORT | MIMECONTF_VALID |
 374              MIMECONTF_VALID_NLS | MIMECONTF_MIME_LATEST,
 375       "x-mac-icelandic", "x-mac-icelandic", "x-mac-icelandic" },
 376     { "Western European (ISO)",
 377       28591, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
 378              MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
 379              MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
 380              MIMECONTF_MIME_LATEST,
 381       "iso-8859-1", "iso-8859-1", "iso-8859-1" },
 382     { "Latin 9 (ISO)",
 383       28605, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT |
 384              MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
 385              MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
 386              MIMECONTF_MIME_LATEST,
 387       "iso-8859-15", "iso-8859-15", "iso-8859-15" }
 388 };
 389 static const MIME_CP_INFO unicode_cp[] =
 390 {
 391     { "Unicode",
 392       CP_UNICODE, MIMECONTF_MINIMAL | MIMECONTF_IMPORT |
 393                   MIMECONTF_SAVABLE_BROWSER | MIMECONTF_EXPORT |
 394                   MIMECONTF_VALID | MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 |
 395                   MIMECONTF_MIME_LATEST,
 396       "unicode", "unicode", "unicode" },
 397     { "Unicode (UTF-7)",
 398       CP_UTF7, MIMECONTF_MAILNEWS | MIMECONTF_IMPORT |
 399                MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_EXPORT | MIMECONTF_VALID |
 400                MIMECONTF_VALID_NLS | MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 401       "utf-7", "utf-7", "utf-7" },
 402     { "Unicode (UTF-8)",
 403       CP_UTF8, MIMECONTF_MAILNEWS | MIMECONTF_BROWSER | MIMECONTF_IMPORT |
 404                MIMECONTF_SAVABLE_MAILNEWS | MIMECONTF_SAVABLE_BROWSER |
 405                MIMECONTF_EXPORT | MIMECONTF_VALID | MIMECONTF_VALID_NLS |
 406                MIMECONTF_MIME_IE4 | MIMECONTF_MIME_LATEST,
 407       "utf-8", "utf-8", "utf-8" }
 408 };
 409
 410 static const struct mlang_data
 411 {
 412     const char *description;
 413     UINT family_codepage;
 414     UINT number_of_cp;
 415     const MIME_CP_INFO *mime_cp_info;
 416     const char *fixed_font;
 417     const char *proportional_font;
 418 } mlang_data[] =
 419 {
 420     { "Arabic",1256,sizeof(arabic_cp)/sizeof(arabic_cp[0]),arabic_cp,
 421       "Courier","Arial" }, /* FIXME */
 422     { "Baltic",1257,sizeof(baltic_cp)/sizeof(baltic_cp[0]),baltic_cp,
 423       "Courier","Arial" }, /* FIXME */
 424     { "Chinese Simplified",936,sizeof(chinese_simplified_cp)/sizeof(chinese_simplified_cp[0]),chinese_simplified_cp,
 425       "Courier","Arial" }, /* FIXME */
 426     { "Chinese Traditional",950,sizeof(chinese_traditional_cp)/sizeof(chinese_traditional_cp[0]),chinese_traditional_cp,
 427       "Courier","Arial" }, /* FIXME */
 428     { "Central European",1250,sizeof(central_european_cp)/sizeof(central_european_cp[0]),central_european_cp,
 429       "Courier","Arial" }, /* FIXME */
 430     { "Cyrillic",1251,sizeof(cyrillic_cp)/sizeof(cyrillic_cp[0]),cyrillic_cp,
 431       "Courier","Arial" }, /* FIXME */
 432     { "Greek",1253,sizeof(greek_cp)/sizeof(greek_cp[0]),greek_cp,
 433       "Courier","Arial" }, /* FIXME */
 434     { "Hebrew",1255,sizeof(hebrew_cp)/sizeof(hebrew_cp[0]),hebrew_cp,
 435       "Courier","Arial" }, /* FIXME */
 436     { "Japanese",932,sizeof(japanese_cp)/sizeof(japanese_cp[0]),japanese_cp,
 437       "Courier","Arial" }, /* FIXME */
 438     { "Korean",949,sizeof(korean_cp)/sizeof(korean_cp[0]),korean_cp,
 439       "Courier","Arial" }, /* FIXME */
 440     { "Thai",874,sizeof(thai_cp)/sizeof(thai_cp[0]),thai_cp,
 441       "Courier","Arial" }, /* FIXME */
 442     { "Turkish",1254,sizeof(turkish_cp)/sizeof(turkish_cp[0]),turkish_cp,
 443       "Courier","Arial" }, /* FIXME */
 444     { "Vietnamese",1258,sizeof(vietnamese_cp)/sizeof(vietnamese_cp[0]),vietnamese_cp,
 445       "Courier","Arial" }, /* FIXME */
 446     { "Western European",1252,sizeof(western_cp)/sizeof(western_cp[0]),western_cp,
 447       "Courier","Arial" }, /* FIXME */
 448     { "Unicode",CP_UNICODE,sizeof(unicode_cp)/sizeof(unicode_cp[0]),unicode_cp,
 449       "Courier","Arial" } /* FIXME */
 450 };
 451
 452 static void fill_cp_info(const struct mlang_data *ml_data, UINT index, MIMECPINFO *mime_cp_info);
 453
 454 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
 455 {
 456     switch(fdwReason) {
 457         case DLL_PROCESS_ATTACH:
 458             DisableThreadLibraryCalls(hInstDLL);
 459             break;
 460         case DLL_PROCESS_DETACH:
 461             break;
 462     }
 463     return TRUE;
 464 }
 465
 466 HRESULT WINAPI ConvertINetMultiByteToUnicode(
 467     LPDWORD pdwMode,
 468     DWORD dwEncoding,
 469     LPCSTR pSrcStr,
 470     LPINT pcSrcSize,
 471     LPWSTR pDstStr,
 472     LPINT pcDstSize)
 473 {
 474     INT src_len = -1;
 475
 476     TRACE("%p %ld %s %p %p %p\n", pdwMode, dwEncoding,
 477           debugstr_a(pSrcStr), pcSrcSize, pDstStr, pcDstSize);
 478
 479     if (!pcDstSize)
 480         return E_FAIL;
 481
 482     if (!pcSrcSize)
 483         pcSrcSize = &src_len;
 484
 485     if (!*pcSrcSize)
 486     {
 487         *pcDstSize = 0;
 488         return S_OK;
 489     }
 490
 491     switch (dwEncoding)
 492     {
 493     case CP_UNICODE:
 494         if (*pcSrcSize == -1)
 495             *pcSrcSize = lstrlenW((LPCWSTR)pSrcStr);
 496         *pcDstSize = min(*pcSrcSize, *pcDstSize);
 497         *pcSrcSize *= sizeof(WCHAR);
 498         if (pDstStr)
 499             memmove(pDstStr, pSrcStr, *pcDstSize * sizeof(WCHAR));
 500         break;
 501
 502     default:
 503         if (*pcSrcSize == -1)
 504             *pcSrcSize = lstrlenA(pSrcStr);
 505
 506         if (pDstStr)
 507             *pcDstSize = MultiByteToWideChar(dwEncoding, 0, pSrcStr, *pcSrcSize, pDstStr, *pcDstSize);
 508         else
 509             *pcDstSize = MultiByteToWideChar(dwEncoding, 0, pSrcStr, *pcSrcSize, NULL, 0);
 510         break;
 511     }
 512
 513     if (!*pcDstSize)
 514         return E_FAIL;
 515
 516     return S_OK;
 517 }
 518
 519 HRESULT WINAPI ConvertINetUnicodeToMultiByte(
 520     LPDWORD pdwMode,
 521     DWORD dwEncoding,
 522     LPCWSTR pSrcStr,
 523     LPINT pcSrcSize,
 524     LPSTR pDstStr,
 525     LPINT pcDstSize)
 526 {
 527
 528     INT src_len = -1;
 529
 530     TRACE("%p %ld %s %p %p %p\n", pdwMode, dwEncoding,
 531           debugstr_w(pSrcStr), pcSrcSize, pDstStr, pcDstSize);
 532
 533     if (!pcDstSize)
 534         return E_FAIL;
 535
 536     if (!pcSrcSize)
 537         pcSrcSize = &src_len;
 538
 539     if (!*pcSrcSize)
 540     {
 541         *pcDstSize = 0;
 542         return S_OK;
 543     }
 544
 545     switch (dwEncoding)
 546     {
 547     case CP_UNICODE:
 548         if (*pcSrcSize == -1)
 549             *pcSrcSize = lstrlenW(pSrcStr);
 550         *pcDstSize = min(*pcSrcSize * sizeof(WCHAR), *pcDstSize);
 551         if (pDstStr)
 552             memmove(pDstStr, pSrcStr, *pcDstSize);
 553         break;
 554
 555     default:
 556         if (*pcSrcSize == -1)
 557             *pcSrcSize = lstrlenW(pSrcStr);
 558
 559         if (pDstStr)
 560             *pcDstSize = WideCharToMultiByte(dwEncoding, 0, pSrcStr, *pcSrcSize, pDstStr, *pcDstSize, NULL, NULL);
 561         else
 562             *pcDstSize = WideCharToMultiByte(dwEncoding, 0, pSrcStr, *pcSrcSize, NULL, 0, NULL, NULL);
 563         break;
 564     }
 565
 566
 567     if (!*pcDstSize)
 568         return E_FAIL;
 569
 570     return S_OK;
 571 }
 572
 573 HRESULT WINAPI ConvertINetString(
 574     LPDWORD pdwMode,
 575     DWORD dwSrcEncoding,
 576     DWORD dwDstEncoding,
 577     LPCSTR pSrcStr,
 578     LPINT pcSrcSize,
 579     LPSTR pDstStr,
 580     LPINT pcDstSize
 581 )
 582 {
 583     FIXME("%p %ld %ld %s %p %p %p: stub!\n", pdwMode, dwSrcEncoding, dwDstEncoding,
 584           debugstr_a(pSrcStr), pcSrcSize, pDstStr, pcDstSize);
 585     return E_NOTIMPL;
 586 }
 587
 588 static HRESULT GetFamilyCodePage(
 589     UINT uiCodePage,
 590     UINT* puiFamilyCodePage)
 591 {
 592     UINT i, n;
 593
 594     TRACE("%u %p\n", uiCodePage, puiFamilyCodePage);
 595
 596     if (!puiFamilyCodePage) return S_FALSE;
 597
 598     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
 599     {
 600         for (n = 0; n < mlang_data[i].number_of_cp; n++)
 601         {
 602             if (mlang_data[i].mime_cp_info[n].cp == uiCodePage)
 603             {
 604                 *puiFamilyCodePage = mlang_data[i].family_codepage;
 605                 return S_OK;
 606             }
 607         }
 608     }
 609
 610     return S_FALSE;
 611 }
 612
 613 HRESULT WINAPI IsConvertINetStringAvailable(
 614     DWORD dwSrcEncoding,
 615     DWORD dwDstEncoding)
 616 {
 617     UINT src_family, dst_family;
 618
 619     TRACE("%ld %ld\n", dwSrcEncoding, dwDstEncoding);
 620
 621     if (GetFamilyCodePage(dwSrcEncoding, &src_family) != S_OK ||
 622         GetFamilyCodePage(dwDstEncoding, &dst_family) != S_OK)
 623         return S_FALSE;
 624
 625     if (src_family == dst_family) return S_OK;
 626
 627     /* we can convert any codepage to/from unicode */
 628     if (src_family == CP_UNICODE || dst_family == CP_UNICODE) return S_OK;
 629
 630     return S_FALSE;
 631 }
 632
 633 HRESULT WINAPI LcidToRfc1766A(
 634     LCID Locale,
 635     LPSTR pszRfc1766,
 636     INT nChar)
 637 {
 638     FIXME("%ld %s %u\n", Locale, pszRfc1766, nChar);
 639     return S_FALSE;
 640 }
 641
 642 HRESULT WINAPI LcidToRfc1766W(
 643     LCID Locale,
 644     LPWSTR pszRfc1766,
 645     INT nChar)
 646 {
 647     FIXME("%ld %p %u\n", Locale, pszRfc1766, nChar);
 648     return S_FALSE;
 649 }
 650
 651 /******************************************************************************
 652  * MLANG ClassFactory
 653  */
 654 typedef struct {
 655     IClassFactory ITF_IClassFactory;
 656
 657     LONG ref;
 658     HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
 659 } IClassFactoryImpl;
 660
 661 struct object_creation_info
 662 {
 663     const CLSID *clsid;
 664     LPCSTR szClassName;
 665     HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
 666 };
 667
 668 static const struct object_creation_info object_creation[] =
 669 {
 670     { &CLSID_CMultiLanguage, "CLSID_CMultiLanguage", MultiLanguage_create },
 671 };
 672
 673 static HRESULT WINAPI
 674 MLANGCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
 675 {
 676     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
 677
 678     TRACE("%s\n", debugstr_guid(riid) );
 679
 680     if (IsEqualGUID(riid, &IID_IUnknown)
 681         || IsEqualGUID(riid, &IID_IClassFactory))
 682     {
 683         IClassFactory_AddRef(iface);
 684         *ppobj = This;
 685         return S_OK;
 686     }
 687
 688     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
 689     return E_NOINTERFACE;
 690 }
 691
 692 static ULONG WINAPI MLANGCF_AddRef(LPCLASSFACTORY iface)
 693 {
 694     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
 695     return InterlockedIncrement(&This->ref);
 696 }
 697
 698 static ULONG WINAPI MLANGCF_Release(LPCLASSFACTORY iface)
 699 {
 700     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
 701
 702     ULONG ref = InterlockedDecrement(&This->ref);
 703
 704     if (ref == 0)
 705     {
 706         TRACE("Destroying %p\n", This);
 707         HeapFree(GetProcessHeap(), 0, This);
 708     }
 709
 710     return ref;
 711 }
 712
 713 static HRESULT WINAPI MLANGCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter,
 714                                           REFIID riid, LPVOID *ppobj)
 715 {
 716     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
 717     HRESULT hres;
 718     LPUNKNOWN punk;
 719
 720     TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
 721
 722     *ppobj = NULL;
 723     hres = This->pfnCreateInstance(pOuter, (LPVOID *) &punk);
 724     if (SUCCEEDED(hres)) {
 725         hres = IUnknown_QueryInterface(punk, riid, ppobj);
 726         IUnknown_Release(punk);
 727     }
 728     TRACE("returning (%p) -> %lx\n", *ppobj, hres);
 729     return hres;
 730 }
 731
 732 static HRESULT WINAPI MLANGCF_LockServer(LPCLASSFACTORY iface,BOOL dolock)
 733 {
 734     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
 735     FIXME("(%p)->(%d),stub!\n",This,dolock);
 736     return S_OK;
 737 }
 738
 739 static const IClassFactoryVtbl MLANGCF_Vtbl =
 740 {
 741     MLANGCF_QueryInterface,
 742     MLANGCF_AddRef,
 743     MLANGCF_Release,
 744     MLANGCF_CreateInstance,
 745     MLANGCF_LockServer
 746 };
 747
 748 /******************************************************************
 749  *              DllGetClassObject (MLANG.@)
 750  */
 751 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
 752 {
 753     int i;
 754     IClassFactoryImpl *factory;
 755
 756     TRACE("%s %s %p\n",debugstr_guid(rclsid), debugstr_guid(iid), ppv);
 757
 758     if ( !IsEqualGUID( &IID_IClassFactory, iid )
 759          && ! IsEqualGUID( &IID_IUnknown, iid) )
 760         return E_NOINTERFACE;
 761
 762     for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
 763     {
 764         if (IsEqualGUID(object_creation[i].clsid, rclsid))
 765             break;
 766     }
 767
 768     if (i == sizeof(object_creation)/sizeof(object_creation[0]))
 769     {
 770         FIXME("%s: no class found.\n", debugstr_guid(rclsid));
 771         return CLASS_E_CLASSNOTAVAILABLE;
 772     }
 773
 774     TRACE("Creating a class factory for %s\n",object_creation[i].szClassName);
 775
 776     factory = HeapAlloc(GetProcessHeap(), 0, sizeof(*factory));
 777     if (factory == NULL) return E_OUTOFMEMORY;
 778
 779     factory->ITF_IClassFactory.lpVtbl = &MLANGCF_Vtbl;
 780     factory->ref = 1;
 781
 782     factory->pfnCreateInstance = object_creation[i].pfnCreateInstance;
 783
 784     *ppv = &(factory->ITF_IClassFactory);
 785
 786     TRACE("(%p) <- %p\n", ppv, &(factory->ITF_IClassFactory) );
 787
 788     return S_OK;
 789 }
 790
 791
 792 /******************************************************************************/
 793
 794 typedef struct tagMLang_impl
 795 {
 796     const IMLangFontLinkVtbl *vtbl_IMLangFontLink;
 797     const IMultiLanguageVtbl *vtbl_IMultiLanguage;
 798     const IMultiLanguage2Vtbl *vtbl_IMultiLanguage2;
 799     LONG ref;
 800     DWORD total_cp, total_scripts;
 801 } MLang_impl;
 802
 803 static ULONG WINAPI MLang_AddRef( MLang_impl* This)
 804 {
 805     return InterlockedIncrement(&This->ref);
 806 }
 807
 808 static ULONG WINAPI MLang_Release( MLang_impl* This )
 809 {
 810     ULONG ref = InterlockedDecrement(&This->ref);
 811
 812     TRACE("%p ref = %ld\n", This, ref);
 813     if (ref == 0)
 814     {
 815         TRACE("Destroying %p\n", This);
 816         HeapFree(GetProcessHeap(), 0, This);
 817     }
 818
 819     return ref;
 820 }
 821
 822 static HRESULT WINAPI MLang_QueryInterface(
 823         MLang_impl* This,
 824         REFIID riid,
 825         void** ppvObject)
 826 {
 827     TRACE("%p -> %s\n", This, debugstr_guid(riid) );
 828
 829     if (IsEqualGUID(riid, &IID_IUnknown)
 830         || IsEqualGUID(riid, &IID_IMLangCodePages)
 831         || IsEqualGUID(riid, &IID_IMLangFontLink))
 832     {
 833         MLang_AddRef(This);
 834         TRACE("Returning IID_IMLangFontLink %p ref = %ld\n", This, This->ref);
 835         *ppvObject = &(This->vtbl_IMLangFontLink);
 836         return S_OK;
 837     }
 838
 839     if (IsEqualGUID(riid, &IID_IMultiLanguage) )
 840     {
 841         MLang_AddRef(This);
 842         TRACE("Returning IID_IMultiLanguage %p ref = %ld\n", This, This->ref);
 843         *ppvObject = &(This->vtbl_IMultiLanguage);
 844         return S_OK;
 845     }
 846
 847     if (IsEqualGUID(riid, &IID_IMultiLanguage2) )
 848     {
 849         MLang_AddRef(This);
 850         *ppvObject = &(This->vtbl_IMultiLanguage2);
 851         TRACE("Returning IID_IMultiLanguage2 %p ref = %ld\n", This, This->ref);
 852         return S_OK;
 853     }
 854
 855     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
 856     return E_NOINTERFACE;
 857 }
 858
 859 /******************************************************************************/
 860
 861 typedef struct tagEnumCodePage_impl
 862 {
 863     const IEnumCodePageVtbl *vtbl_IEnumCodePage;
 864     LONG ref;
 865     MIMECPINFO *cpinfo;
 866     DWORD total, pos;
 867 } EnumCodePage_impl;
 868
 869 static HRESULT WINAPI fnIEnumCodePage_QueryInterface(
 870         IEnumCodePage* iface,
 871         REFIID riid,
 872         void** ppvObject)
 873 {
 874     ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
 875
 876     TRACE("%p -> %s\n", This, debugstr_guid(riid) );
 877
 878     if (IsEqualGUID(riid, &IID_IUnknown)
 879         || IsEqualGUID(riid, &IID_IEnumCodePage))
 880     {
 881         IEnumCodePage_AddRef(iface);
 882         TRACE("Returning IID_IEnumCodePage %p ref = %ld\n", This, This->ref);
 883         *ppvObject = &(This->vtbl_IEnumCodePage);
 884         return S_OK;
 885     }
 886
 887     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
 888     return E_NOINTERFACE;
 889 }
 890
 891 static ULONG WINAPI fnIEnumCodePage_AddRef(
 892         IEnumCodePage* iface)
 893 {
 894     ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
 895     return InterlockedIncrement(&This->ref);
 896 }
 897
 898 static ULONG WINAPI fnIEnumCodePage_Release(
 899         IEnumCodePage* iface)
 900 {
 901     ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
 902     ULONG ref = InterlockedDecrement(&This->ref);
 903
 904     TRACE("%p ref = %ld\n", This, ref);
 905     if (ref == 0)
 906     {
 907         TRACE("Destroying %p\n", This);
 908         HeapFree(GetProcessHeap(), 0, This->cpinfo);
 909         HeapFree(GetProcessHeap(), 0, This);
 910     }
 911
 912     return ref;
 913 }
 914
 915 static HRESULT WINAPI fnIEnumCodePage_Clone(
 916         IEnumCodePage* iface,
 917         IEnumCodePage** ppEnum)
 918 {
 919     ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
 920     FIXME("%p %p\n", This, ppEnum);
 921     return E_NOTIMPL;
 922 }
 923
 924 static  HRESULT WINAPI fnIEnumCodePage_Next(
 925         IEnumCodePage* iface,
 926         ULONG celt,
 927         PMIMECPINFO rgelt,
 928         ULONG* pceltFetched)
 929 {
 930     ULONG i;
 931
 932     ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
 933     TRACE("%p %lu %p %p\n", This, celt, rgelt, pceltFetched);
 934
 935     if (!pceltFetched) return S_FALSE;
 936     *pceltFetched = 0;
 937
 938     if (!rgelt) return S_FALSE;
 939
 940     if (This->pos + celt > This->total)
 941         celt = This->total - This->pos;
 942
 943     if (!celt) return S_FALSE;
 944
 945     memcpy(rgelt, This->cpinfo + This->pos, celt * sizeof(MIMECPINFO));
 946     *pceltFetched = celt;
 947     This->pos += celt;
 948
 949     for (i = 0; i < celt; i++)
 950     {
 951         TRACE("#%lu: %08lx %u %u %s %s %s %s %s %s %d\n",
 952               i, rgelt[i].dwFlags, rgelt[i].uiCodePage,
 953               rgelt[i].uiFamilyCodePage,
 954               wine_dbgstr_w(rgelt[i].wszDescription),
 955               wine_dbgstr_w(rgelt[i].wszWebCharset),
 956               wine_dbgstr_w(rgelt[i].wszHeaderCharset),
 957               wine_dbgstr_w(rgelt[i].wszBodyCharset),
 958               wine_dbgstr_w(rgelt[i].wszFixedWidthFont),
 959               wine_dbgstr_w(rgelt[i].wszProportionalFont),
 960               rgelt[i].bGDICharset);
 961     }
 962     return S_OK;
 963 }
 964
 965 static HRESULT WINAPI fnIEnumCodePage_Reset(
 966         IEnumCodePage* iface)
 967 {
 968     ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
 969     TRACE("%p\n", This);
 970
 971     This->pos = 0;
 972     return S_OK;
 973 }
 974
 975 static  HRESULT WINAPI fnIEnumCodePage_Skip(
 976         IEnumCodePage* iface,
 977         ULONG celt)
 978 {
 979     ICOM_THIS_MULTI(EnumCodePage_impl, vtbl_IEnumCodePage, iface);
 980     TRACE("%p %lu\n", This, celt);
 981
 982     if (celt >= This->total) return S_FALSE;
 983
 984     This->pos = celt;  /* FIXME: should be += ?? */
 985     return S_OK;
 986 }
 987
 988 static const IEnumCodePageVtbl IEnumCodePage_vtbl =
 989 {
 990     fnIEnumCodePage_QueryInterface,
 991     fnIEnumCodePage_AddRef,
 992     fnIEnumCodePage_Release,
 993     fnIEnumCodePage_Clone,
 994     fnIEnumCodePage_Next,
 995     fnIEnumCodePage_Reset,
 996     fnIEnumCodePage_Skip
 997 };
 998
 999 static HRESULT EnumCodePage_create( MLang_impl* mlang, DWORD grfFlags,
1000                      LANGID LangId, IEnumCodePage** ppEnumCodePage )
1001 {
1002     EnumCodePage_impl *ecp;
1003     MIMECPINFO *cpinfo;
1004     UINT i, n;
1005
1006     TRACE("%p, %08lx, %04x, %p\n", mlang, grfFlags, LangId, ppEnumCodePage);
1007
1008     if (!grfFlags) /* enumerate internal data base of encodings */
1009         grfFlags = MIMECONTF_MIME_LATEST;
1010
1011     ecp = HeapAlloc( GetProcessHeap(), 0, sizeof (EnumCodePage_impl) );
1012     ecp->vtbl_IEnumCodePage = &IEnumCodePage_vtbl;
1013     ecp->ref = 1;
1014     ecp->pos = 0;
1015     ecp->total = 0;
1016     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1017     {
1018         for (n = 0; n < mlang_data[i].number_of_cp; n++)
1019         {
1020             if (mlang_data[i].mime_cp_info[n].flags & grfFlags)
1021                 ecp->total++;
1022         }
1023     }
1024
1025     ecp->cpinfo = HeapAlloc(GetProcessHeap(), 0,
1026                             sizeof(MIMECPINFO) * ecp->total);
1027     cpinfo = ecp->cpinfo;
1028
1029     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1030     {
1031         for (n = 0; n < mlang_data[i].number_of_cp; n++)
1032         {
1033             if (mlang_data[i].mime_cp_info[n].flags & grfFlags)
1034                 fill_cp_info(&mlang_data[i], n, cpinfo++);
1035         }
1036     }
1037
1038     TRACE("enumerated %ld codepages with flags %08lx\n", ecp->total, grfFlags);
1039
1040     *ppEnumCodePage = (IEnumCodePage*) ecp;
1041
1042     return S_OK;
1043 }
1044
1045 /******************************************************************************/
1046
1047 typedef struct tagEnumScript_impl
1048 {
1049     const IEnumScriptVtbl *vtbl_IEnumScript;
1050     LONG ref;
1051     SCRIPTINFO *script_info;
1052     DWORD total, pos;
1053 } EnumScript_impl;
1054
1055 static HRESULT WINAPI fnIEnumScript_QueryInterface(
1056         IEnumScript* iface,
1057         REFIID riid,
1058         void** ppvObject)
1059 {
1060     ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1061
1062     TRACE("%p -> %s\n", This, debugstr_guid(riid) );
1063
1064     if (IsEqualGUID(riid, &IID_IUnknown)
1065         || IsEqualGUID(riid, &IID_IEnumScript))
1066     {
1067         IEnumScript_AddRef(iface);
1068         TRACE("Returning IID_IEnumScript %p ref = %ld\n", This, This->ref);
1069         *ppvObject = &(This->vtbl_IEnumScript);
1070         return S_OK;
1071     }
1072
1073     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1074     return E_NOINTERFACE;
1075 }
1076
1077 static ULONG WINAPI fnIEnumScript_AddRef(
1078         IEnumScript* iface)
1079 {
1080     ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1081     return InterlockedIncrement(&This->ref);
1082 }
1083
1084 static ULONG WINAPI fnIEnumScript_Release(
1085         IEnumScript* iface)
1086 {
1087     ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1088     ULONG ref = InterlockedDecrement(&This->ref);
1089
1090     TRACE("%p ref = %ld\n", This, ref);
1091     if (ref == 0)
1092     {
1093         TRACE("Destroying %p\n", This);
1094         HeapFree(GetProcessHeap(), 0, This);
1095     }
1096
1097     return ref;
1098 }
1099
1100 static HRESULT WINAPI fnIEnumScript_Clone(
1101         IEnumScript* iface,
1102         IEnumScript** ppEnum)
1103 {
1104     ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1105     FIXME("%p %p: stub!\n", This, ppEnum);
1106     return E_NOTIMPL;
1107 }
1108
1109 static  HRESULT WINAPI fnIEnumScript_Next(
1110         IEnumScript* iface,
1111         ULONG celt,
1112         PSCRIPTINFO rgelt,
1113         ULONG* pceltFetched)
1114 {
1115     ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1116     TRACE("%p %lu %p %p\n", This, celt, rgelt, pceltFetched);
1117
1118     if (!pceltFetched || !rgelt) return E_FAIL;
1119
1120     *pceltFetched = 0;
1121
1122     if (This->pos + celt > This->total)
1123         celt = This->total - This->pos;
1124
1125     if (!celt) return S_FALSE;
1126
1127     memcpy(rgelt, This->script_info + This->pos, celt * sizeof(SCRIPTINFO));
1128     *pceltFetched = celt;
1129     This->pos += celt;
1130
1131     return S_OK;
1132 }
1133
1134 static HRESULT WINAPI fnIEnumScript_Reset(
1135         IEnumScript* iface)
1136 {
1137     ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1138     TRACE("%p\n", This);
1139
1140     This->pos = 0;
1141     return S_OK;
1142 }
1143
1144 static  HRESULT WINAPI fnIEnumScript_Skip(
1145         IEnumScript* iface,
1146         ULONG celt)
1147 {
1148     ICOM_THIS_MULTI(EnumScript_impl, vtbl_IEnumScript, iface);
1149     TRACE("%p %lu\n", This, celt);
1150
1151     if (celt >= This->total) return S_FALSE;
1152
1153     This->pos = celt;  /* FIXME: should be += ?? */
1154     return S_OK;
1155 }
1156
1157 static const IEnumScriptVtbl IEnumScript_vtbl =
1158 {
1159     fnIEnumScript_QueryInterface,
1160     fnIEnumScript_AddRef,
1161     fnIEnumScript_Release,
1162     fnIEnumScript_Clone,
1163     fnIEnumScript_Next,
1164     fnIEnumScript_Reset,
1165     fnIEnumScript_Skip
1166 };
1167
1168 static HRESULT EnumScript_create( MLang_impl* mlang, DWORD dwFlags,
1169                      LANGID LangId, IEnumScript** ppEnumScript )
1170 {
1171     EnumScript_impl *es;
1172     UINT i;
1173
1174     TRACE("%p, %08lx, %04x, %p: stub!\n", mlang, dwFlags, LangId, ppEnumScript);
1175
1176     if (!dwFlags) /* enumerate all available scripts */
1177         dwFlags = SCRIPTCONTF_SCRIPT_USER | SCRIPTCONTF_SCRIPT_HIDE | SCRIPTCONTF_SCRIPT_SYSTEM;
1178
1179     es = HeapAlloc( GetProcessHeap(), 0, sizeof (EnumScript_impl) );
1180     es->vtbl_IEnumScript = &IEnumScript_vtbl;
1181     es->ref = 1;
1182     es->pos = 0;
1183     /* do not enumerate unicode flavours */
1184     es->total = sizeof(mlang_data)/sizeof(mlang_data[0]) - 1;
1185     es->script_info = HeapAlloc(GetProcessHeap(), 0, sizeof(SCRIPTINFO) * es->total);
1186
1187     for (i = 0; i < es->total; i++)
1188     {
1189         es->script_info[i].ScriptId = i;
1190         es->script_info[i].uiCodePage = mlang_data[i].family_codepage;
1191         MultiByteToWideChar(CP_ACP, 0, mlang_data[i].description, -1,
1192             es->script_info[i].wszDescription, MAX_SCRIPT_NAME);
1193         MultiByteToWideChar(CP_ACP, 0, mlang_data[i].fixed_font, -1,
1194             es->script_info[i].wszFixedWidthFont, MAX_MIMEFACE_NAME);
1195         MultiByteToWideChar(CP_ACP, 0, mlang_data[i].proportional_font, -1,
1196             es->script_info[i].wszProportionalFont, MAX_MIMEFACE_NAME);
1197     }
1198
1199     TRACE("enumerated %ld scripts with flags %08lx\n", es->total, dwFlags);
1200
1201     *ppEnumScript = (IEnumScript *)es;
1202
1203     return S_OK;
1204 }
1205
1206 /******************************************************************************/
1207
1208 static HRESULT WINAPI fnIMLangFontLink_QueryInterface(
1209         IMLangFontLink* iface,
1210         REFIID riid,
1211         void** ppvObject)
1212 {
1213     ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1214     return MLang_QueryInterface( This, riid, ppvObject );
1215 }
1216
1217 static ULONG WINAPI fnIMLangFontLink_AddRef(
1218         IMLangFontLink* iface)
1219 {
1220     ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1221     return MLang_AddRef( This );
1222 }
1223
1224 static ULONG WINAPI fnIMLangFontLink_Release(
1225         IMLangFontLink* iface)
1226 {
1227     ICOM_THIS_MULTI(MLang_impl, vtbl_IMLangFontLink, iface);
1228     return MLang_Release( This );
1229 }
1230
1231 static HRESULT WINAPI fnIMLangFontLink_GetCharCodePages(
1232         IMLangFontLink* iface,
1233         WCHAR chSrc,
1234         DWORD* pdwCodePages)
1235 {
1236     FIXME("\n");
1237     return E_NOTIMPL;
1238 }
1239
1240 static HRESULT WINAPI fnIMLangFontLink_GetStrCodePages(
1241         IMLangFontLink* iface,
1242         const WCHAR* pszSrc,
1243         long cchSrc,
1244         DWORD dwPriorityCodePages,
1245         DWORD* pdwCodePages,
1246         long* pcchCodePages)
1247 {
1248     FIXME("\n");
1249     return E_NOTIMPL;
1250 }
1251
1252 static HRESULT WINAPI fnIMLangFontLink_CodePageToCodePages(
1253         IMLangFontLink* iface,
1254         UINT uCodePage,
1255         DWORD* pdwCodePages)
1256 {
1257     FIXME("\n");
1258     return E_NOTIMPL;
1259 }
1260
1261 static HRESULT WINAPI fnIMLangFontLink_CodePagesToCodePage(
1262         IMLangFontLink* iface,
1263         DWORD dwCodePages,
1264         UINT uDefaultCodePage,
1265         UINT* puCodePage)
1266 {
1267     FIXME("\n");
1268     return E_NOTIMPL;
1269 }
1270
1271 static HRESULT WINAPI fnIMLangFontLink_GetFontCodePages(
1272         IMLangFontLink* iface,
1273         HDC hDC,
1274         HFONT hFont,
1275         DWORD* pdwCodePages)
1276 {
1277     FIXME("\n");
1278     return E_NOTIMPL;
1279 }
1280
1281 static HRESULT WINAPI fnIMLangFontLink_MapFont(
1282         IMLangFontLink* iface,
1283         HDC hDC,
1284         DWORD dwCodePages,
1285         HFONT hSrcFont,
1286         HFONT* phDestFont)
1287 {
1288     FIXME("\n");
1289     return E_NOTIMPL;
1290 }
1291
1292 static HRESULT WINAPI fnIMLangFontLink_ReleaseFont(
1293         IMLangFontLink* iface,
1294         HFONT hFont)
1295 {
1296     FIXME("\n");
1297     return E_NOTIMPL;
1298 }
1299
1300 static HRESULT WINAPI fnIMLangFontLink_ResetFontMapping(
1301         IMLangFontLink* iface)
1302 {
1303     FIXME("\n");
1304     return E_NOTIMPL;
1305 }
1306
1307
1308 static const IMLangFontLinkVtbl IMLangFontLink_vtbl =
1309 {
1310     fnIMLangFontLink_QueryInterface,
1311     fnIMLangFontLink_AddRef,
1312     fnIMLangFontLink_Release,
1313     fnIMLangFontLink_GetCharCodePages,
1314     fnIMLangFontLink_GetStrCodePages,
1315     fnIMLangFontLink_CodePageToCodePages,
1316     fnIMLangFontLink_CodePagesToCodePage,
1317     fnIMLangFontLink_GetFontCodePages,
1318     fnIMLangFontLink_MapFont,
1319     fnIMLangFontLink_ReleaseFont,
1320     fnIMLangFontLink_ResetFontMapping,
1321 };
1322
1323 /******************************************************************************/
1324
1325 static HRESULT WINAPI fnIMultiLanguage_QueryInterface(
1326     IMultiLanguage* iface,
1327     REFIID riid,
1328     void** ppvObject)
1329 {
1330     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1331     return MLang_QueryInterface( This, riid, ppvObject );
1332 }
1333
1334 static ULONG WINAPI fnIMultiLanguage_AddRef( IMultiLanguage* iface )
1335 {
1336     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1337     return IMLangFontLink_AddRef( ((IMLangFontLink*)This) );
1338 }
1339
1340 static ULONG WINAPI fnIMultiLanguage_Release( IMultiLanguage* iface )
1341 {
1342     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1343     return IMLangFontLink_Release( ((IMLangFontLink*)This) );
1344 }
1345
1346 static HRESULT WINAPI fnIMultiLanguage_GetNumberOfCodePageInfo(
1347     IMultiLanguage* iface,
1348     UINT* pcCodePage)
1349 {
1350     FIXME("\n");
1351     return E_NOTIMPL;
1352 }
1353
1354 static HRESULT WINAPI fnIMultiLanguage_GetCodePageInfo(
1355     IMultiLanguage* iface,
1356     UINT uiCodePage,
1357     PMIMECPINFO pCodePageInfo)
1358 {
1359     FIXME("\n");
1360     return E_NOTIMPL;
1361 }
1362
1363 static HRESULT WINAPI fnIMultiLanguage_GetFamilyCodePage(
1364     IMultiLanguage* iface,
1365     UINT uiCodePage,
1366     UINT* puiFamilyCodePage)
1367 {
1368     return GetFamilyCodePage(uiCodePage, puiFamilyCodePage);
1369 }
1370
1371 static HRESULT WINAPI fnIMultiLanguage_EnumCodePages(
1372     IMultiLanguage* iface,
1373     DWORD grfFlags,
1374     IEnumCodePage** ppEnumCodePage)
1375 {
1376     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage, iface);
1377     TRACE("%p %08lx %p\n", This, grfFlags, ppEnumCodePage);
1378
1379     return EnumCodePage_create( This, grfFlags, 0, ppEnumCodePage );
1380 }
1381
1382 static HRESULT WINAPI fnIMultiLanguage_GetCharsetInfo(
1383     IMultiLanguage* iface,
1384     BSTR Charset,
1385     PMIMECSETINFO pCharsetInfo)
1386 {
1387     FIXME("\n");
1388     return E_NOTIMPL;
1389 }
1390
1391 static HRESULT WINAPI fnIMultiLanguage_IsConvertible(
1392     IMultiLanguage* iface,
1393     DWORD dwSrcEncoding,
1394     DWORD dwDstEncoding)
1395 {
1396     return IsConvertINetStringAvailable(dwSrcEncoding, dwDstEncoding);
1397 }
1398
1399 static HRESULT WINAPI fnIMultiLanguage_ConvertString(
1400     IMultiLanguage* iface,
1401     DWORD* pdwMode,
1402     DWORD dwSrcEncoding,
1403     DWORD dwDstEncoding,
1404     BYTE* pSrcStr,
1405     UINT* pcSrcSize,
1406     BYTE* pDstStr,
1407     UINT* pcDstSize)
1408 {
1409     return ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding,
1410                              pSrcStr, pcSrcSize, pDstStr, pcDstSize);
1411 }
1412
1413 static HRESULT WINAPI fnIMultiLanguage_ConvertStringToUnicode(
1414     IMultiLanguage* iface,
1415     DWORD* pdwMode,
1416     DWORD dwEncoding,
1417     CHAR* pSrcStr,
1418     UINT* pcSrcSize,
1419     WCHAR* pDstStr,
1420     UINT* pcDstSize)
1421 {
1422     return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
1423                                          pSrcStr, pcSrcSize, pDstStr, pcDstSize);
1424 }
1425
1426 static HRESULT WINAPI fnIMultiLanguage_ConvertStringFromUnicode(
1427     IMultiLanguage* iface,
1428     DWORD* pdwMode,
1429     DWORD dwEncoding,
1430     WCHAR* pSrcStr,
1431     UINT* pcSrcSize,
1432     CHAR* pDstStr,
1433     UINT* pcDstSize)
1434 {
1435     return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
1436                                          pSrcStr, pcSrcSize, pDstStr, pcDstSize);
1437 }
1438
1439 static HRESULT WINAPI fnIMultiLanguage_ConvertStringReset(
1440     IMultiLanguage* iface)
1441 {
1442     FIXME("\n");
1443     return E_NOTIMPL;
1444 }
1445
1446 static HRESULT WINAPI fnIMultiLanguage_GetRfc1766FromLcid(
1447     IMultiLanguage* iface,
1448     LCID Locale,
1449     BSTR* pbstrRfc1766)
1450 {
1451     FIXME("\n");
1452     return E_NOTIMPL;
1453 }
1454
1455 static HRESULT WINAPI fnIMultiLanguage_GetLcidFromRfc1766(
1456     IMultiLanguage* iface,
1457     LCID* pLocale,
1458     BSTR bstrRfc1766)
1459 {
1460     FIXME("\n");
1461     return E_NOTIMPL;
1462 }
1463
1464 static HRESULT WINAPI fnIMultiLanguage_EnumRfc1766(
1465     IMultiLanguage* iface,
1466     IEnumRfc1766** ppEnumRfc1766)
1467 {
1468     FIXME("\n");
1469     return E_NOTIMPL;
1470 }
1471
1472 static HRESULT WINAPI fnIMultiLanguage_GetRfc1766Info(
1473     IMultiLanguage* iface,
1474     LCID Locale,
1475     PRFC1766INFO pRfc1766Info)
1476 {
1477     FIXME("\n");
1478     return E_NOTIMPL;
1479 }
1480
1481 static HRESULT WINAPI fnIMultiLanguage_CreateConvertCharset(
1482     IMultiLanguage* iface,
1483     UINT uiSrcCodePage,
1484     UINT uiDstCodePage,
1485     DWORD dwProperty,
1486     IMLangConvertCharset** ppMLangConvertCharset)
1487 {
1488     FIXME("\n");
1489     return E_NOTIMPL;
1490 }
1491
1492 static const IMultiLanguageVtbl IMultiLanguage_vtbl =
1493 {
1494     fnIMultiLanguage_QueryInterface,
1495     fnIMultiLanguage_AddRef,
1496     fnIMultiLanguage_Release,
1497     fnIMultiLanguage_GetNumberOfCodePageInfo,
1498     fnIMultiLanguage_GetCodePageInfo,
1499     fnIMultiLanguage_GetFamilyCodePage,
1500     fnIMultiLanguage_EnumCodePages,
1501     fnIMultiLanguage_GetCharsetInfo,
1502     fnIMultiLanguage_IsConvertible,
1503     fnIMultiLanguage_ConvertString,
1504     fnIMultiLanguage_ConvertStringToUnicode,
1505     fnIMultiLanguage_ConvertStringFromUnicode,
1506     fnIMultiLanguage_ConvertStringReset,
1507     fnIMultiLanguage_GetRfc1766FromLcid,
1508     fnIMultiLanguage_GetLcidFromRfc1766,
1509     fnIMultiLanguage_EnumRfc1766,
1510     fnIMultiLanguage_GetRfc1766Info,
1511     fnIMultiLanguage_CreateConvertCharset,
1512 };
1513
1514
1515 /******************************************************************************/
1516
1517 static HRESULT WINAPI fnIMultiLanguage2_QueryInterface(
1518     IMultiLanguage2* iface,
1519     REFIID riid,
1520     void** ppvObject)
1521 {
1522     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage2, iface);
1523     return MLang_QueryInterface( This, riid, ppvObject );
1524 }
1525
1526 static ULONG WINAPI fnIMultiLanguage2_AddRef( IMultiLanguage2* iface )
1527 {
1528     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage2, iface);
1529     return MLang_AddRef( This );
1530 }
1531
1532 static ULONG WINAPI fnIMultiLanguage2_Release( IMultiLanguage2* iface )
1533 {
1534     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage2, iface);
1535     return MLang_Release( This );
1536 }
1537
1538 static HRESULT WINAPI fnIMultiLanguage2_GetNumberOfCodePageInfo(
1539     IMultiLanguage2* iface,
1540     UINT* pcCodePage)
1541 {
1542     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage2, iface);
1543     TRACE("%p, %p\n", This, pcCodePage);
1544
1545     if (!pcCodePage) return S_FALSE;
1546
1547     *pcCodePage = This->total_cp;
1548     return S_OK;
1549 }
1550
1551 static void fill_cp_info(const struct mlang_data *ml_data, UINT index, MIMECPINFO *mime_cp_info)
1552 {
1553     CHARSETINFO csi;
1554
1555     if (TranslateCharsetInfo((DWORD *)ml_data->family_codepage, &csi, TCI_SRCCODEPAGE))
1556         mime_cp_info->bGDICharset = csi.ciCharset;
1557     else
1558         mime_cp_info->bGDICharset = DEFAULT_CHARSET;
1559
1560     mime_cp_info->dwFlags = ml_data->mime_cp_info[index].flags;
1561     mime_cp_info->uiCodePage = ml_data->mime_cp_info[index].cp;
1562     mime_cp_info->uiFamilyCodePage = ml_data->family_codepage;
1563     MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].description, -1,
1564                         mime_cp_info->wszDescription, sizeof(mime_cp_info->wszDescription)/sizeof(WCHAR));
1565     MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].web_charset, -1,
1566                         mime_cp_info->wszWebCharset, sizeof(mime_cp_info->wszWebCharset)/sizeof(WCHAR));
1567     MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].header_charset, -1,
1568                         mime_cp_info->wszHeaderCharset, sizeof(mime_cp_info->wszHeaderCharset)/sizeof(WCHAR));
1569     MultiByteToWideChar(CP_ACP, 0, ml_data->mime_cp_info[index].body_charset, -1,
1570                         mime_cp_info->wszBodyCharset, sizeof(mime_cp_info->wszBodyCharset)/sizeof(WCHAR));
1571
1572     MultiByteToWideChar(CP_ACP, 0, ml_data->fixed_font, -1,
1573         mime_cp_info->wszFixedWidthFont, sizeof(mime_cp_info->wszFixedWidthFont)/sizeof(WCHAR));
1574     MultiByteToWideChar(CP_ACP, 0, ml_data->proportional_font, -1,
1575         mime_cp_info->wszProportionalFont, sizeof(mime_cp_info->wszProportionalFont)/sizeof(WCHAR));
1576
1577     TRACE("%08lx %u %u %s %s %s %s %s %s %d\n",
1578           mime_cp_info->dwFlags, mime_cp_info->uiCodePage,
1579           mime_cp_info->uiFamilyCodePage,
1580           wine_dbgstr_w(mime_cp_info->wszDescription),
1581           wine_dbgstr_w(mime_cp_info->wszWebCharset),
1582           wine_dbgstr_w(mime_cp_info->wszHeaderCharset),
1583           wine_dbgstr_w(mime_cp_info->wszBodyCharset),
1584           wine_dbgstr_w(mime_cp_info->wszFixedWidthFont),
1585           wine_dbgstr_w(mime_cp_info->wszProportionalFont),
1586           mime_cp_info->bGDICharset);
1587 }
1588
1589 static HRESULT WINAPI fnIMultiLanguage2_GetCodePageInfo(
1590     IMultiLanguage2* iface,
1591     UINT uiCodePage,
1592     LANGID LangId,
1593     PMIMECPINFO pCodePageInfo)
1594 {
1595     UINT i, n;
1596
1597     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage2, iface);
1598     TRACE("%p, %u, %04x, %p\n", This, uiCodePage, LangId, pCodePageInfo);
1599
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].cp == uiCodePage)
1605             {
1606                 fill_cp_info(&mlang_data[i], n, pCodePageInfo);
1607                 return S_OK;
1608             }
1609         }
1610     }
1611
1612     return S_FALSE;
1613 }
1614
1615 static HRESULT WINAPI fnIMultiLanguage2_GetFamilyCodePage(
1616     IMultiLanguage2* iface,
1617     UINT uiCodePage,
1618     UINT* puiFamilyCodePage)
1619 {
1620     return GetFamilyCodePage(uiCodePage, puiFamilyCodePage);
1621 }
1622
1623 static HRESULT WINAPI fnIMultiLanguage2_EnumCodePages(
1624     IMultiLanguage2* iface,
1625     DWORD grfFlags,
1626     LANGID LangId,
1627     IEnumCodePage** ppEnumCodePage)
1628 {
1629     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage2, iface);
1630     TRACE("%p %08lx %04x %p\n", This, grfFlags, LangId, ppEnumCodePage);
1631
1632     return EnumCodePage_create( This, grfFlags, LangId, ppEnumCodePage );
1633 }
1634
1635 static HRESULT WINAPI fnIMultiLanguage2_GetCharsetInfo(
1636     IMultiLanguage2* iface,
1637     BSTR Charset,
1638     PMIMECSETINFO pCharsetInfo)
1639 {
1640     UINT i, n;
1641
1642     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage2, iface);
1643     TRACE("%p %s %p\n", This, debugstr_w(Charset), pCharsetInfo);
1644
1645     if (!pCharsetInfo) return E_FAIL;
1646
1647     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1648     {
1649         for (n = 0; n < mlang_data[i].number_of_cp; n++)
1650         {
1651             WCHAR csetW[MAX_MIMECSET_NAME];
1652
1653             MultiByteToWideChar(CP_ACP, 0, mlang_data[i].mime_cp_info[n].web_charset, -1, csetW, MAX_MIMECSET_NAME);
1654             if (!lstrcmpiW(Charset, csetW))
1655             {
1656                 pCharsetInfo->uiCodePage = mlang_data[i].family_codepage;
1657                 pCharsetInfo->uiInternetEncoding = mlang_data[i].mime_cp_info[n].cp;
1658                 strcpyW(pCharsetInfo->wszCharset, csetW);
1659                 return S_OK;
1660             }
1661         }
1662     }
1663
1664     /* FIXME:
1665      * Since we do not support charsets like iso-2022-jp and do not have
1666      * them in our database as a primary (web_charset) encoding this loop
1667      * does an attempt to 'approximate' charset name by header_charset.
1668      */
1669     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1670     {
1671         for (n = 0; n < mlang_data[i].number_of_cp; n++)
1672         {
1673             WCHAR csetW[MAX_MIMECSET_NAME];
1674
1675             MultiByteToWideChar(CP_ACP, 0, mlang_data[i].mime_cp_info[n].header_charset, -1, csetW, MAX_MIMECSET_NAME);
1676             if (!lstrcmpiW(Charset, csetW))
1677             {
1678                 pCharsetInfo->uiCodePage = mlang_data[i].family_codepage;
1679                 pCharsetInfo->uiInternetEncoding = mlang_data[i].mime_cp_info[n].cp;
1680                 strcpyW(pCharsetInfo->wszCharset, csetW);
1681                 return S_OK;
1682             }
1683         }
1684     }
1685
1686     return E_FAIL;
1687 }
1688
1689 static HRESULT WINAPI fnIMultiLanguage2_IsConvertible(
1690     IMultiLanguage2* iface,
1691     DWORD dwSrcEncoding,
1692     DWORD dwDstEncoding)
1693 {
1694     return IsConvertINetStringAvailable(dwSrcEncoding, dwDstEncoding);
1695 }
1696
1697 static HRESULT WINAPI fnIMultiLanguage2_ConvertString(
1698     IMultiLanguage2* iface,
1699     DWORD* pdwMode,
1700     DWORD dwSrcEncoding,
1701     DWORD dwDstEncoding,
1702     BYTE* pSrcStr,
1703     UINT* pcSrcSize,
1704     BYTE* pDstStr,
1705     UINT* pcDstSize)
1706 {
1707     return ConvertINetString(pdwMode, dwSrcEncoding, dwDstEncoding,
1708                              pSrcStr, pcSrcSize, pDstStr, pcDstSize);
1709 }
1710
1711 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicode(
1712     IMultiLanguage2* iface,
1713     DWORD* pdwMode,
1714     DWORD dwEncoding,
1715     CHAR* pSrcStr,
1716     UINT* pcSrcSize,
1717     WCHAR* pDstStr,
1718     UINT* pcDstSize)
1719 {
1720     return ConvertINetMultiByteToUnicode(pdwMode, dwEncoding,
1721                                          pSrcStr, pcSrcSize, pDstStr, pcDstSize);
1722 }
1723
1724 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringFromUnicode(
1725     IMultiLanguage2* iface,
1726     DWORD* pdwMode,
1727     DWORD dwEncoding,
1728     WCHAR* pSrcStr,
1729     UINT* pcSrcSize,
1730     CHAR* pDstStr,
1731     UINT* pcDstSize)
1732 {
1733     return ConvertINetUnicodeToMultiByte(pdwMode, dwEncoding,
1734                                          pSrcStr, pcSrcSize, pDstStr, pcDstSize);
1735 }
1736
1737 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringReset(
1738     IMultiLanguage2* iface)
1739 {
1740     FIXME("\n");
1741     return E_NOTIMPL;
1742 }
1743
1744 static HRESULT WINAPI fnIMultiLanguage2_GetRfc1766FromLcid(
1745     IMultiLanguage2* iface,
1746     LCID Locale,
1747     BSTR* pbstrRfc1766)
1748 {
1749     FIXME("\n");
1750     return E_NOTIMPL;
1751 }
1752
1753 static HRESULT WINAPI fnIMultiLanguage2_GetLcidFromRfc1766(
1754     IMultiLanguage2* iface,
1755     LCID* pLocale,
1756     BSTR bstrRfc1766)
1757 {
1758     FIXME("\n");
1759     return E_NOTIMPL;
1760 }
1761
1762 static HRESULT WINAPI fnIMultiLanguage2_EnumRfc1766(
1763     IMultiLanguage2* iface,
1764     LANGID LangId,
1765     IEnumRfc1766** ppEnumRfc1766)
1766 {
1767     FIXME("\n");
1768     return E_NOTIMPL;
1769 }
1770
1771 static HRESULT WINAPI fnIMultiLanguage2_GetRfc1766Info(
1772     IMultiLanguage2* iface,
1773     LCID Locale,
1774     LANGID LangId,
1775     PRFC1766INFO pRfc1766Info)
1776 {
1777     FIXME("\n");
1778     return E_NOTIMPL;
1779 }
1780
1781 static HRESULT WINAPI fnIMultiLanguage2_CreateConvertCharset(
1782     IMultiLanguage2* iface,
1783     UINT uiSrcCodePage,
1784     UINT uiDstCodePage,
1785     DWORD dwProperty,
1786     IMLangConvertCharset** ppMLangConvertCharset)
1787 {
1788     FIXME("\n");
1789     return E_NOTIMPL;
1790 }
1791
1792 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringInIStream(
1793     IMultiLanguage2* iface,
1794     DWORD* pdwMode,
1795     DWORD dwFlag,
1796     WCHAR* lpFallBack,
1797     DWORD dwSrcEncoding,
1798     DWORD dwDstEncoding,
1799     IStream* pstmIn,
1800     IStream* pstmOut)
1801 {
1802     FIXME("\n");
1803     return E_NOTIMPL;
1804 }
1805
1806 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringToUnicodeEx(
1807     IMultiLanguage2* iface,
1808     DWORD* pdwMode,
1809     DWORD dwEncoding,
1810     CHAR* pSrcStr,
1811     UINT* pcSrcSize,
1812     WCHAR* pDstStr,
1813     UINT* pcDstSize,
1814     DWORD dwFlag,
1815     WCHAR* lpFallBack)
1816 {
1817     FIXME("\n");
1818     return E_NOTIMPL;
1819 }
1820
1821 static HRESULT WINAPI fnIMultiLanguage2_ConvertStringFromUnicodeEx(
1822     IMultiLanguage2* This,
1823     DWORD* pdwMode,
1824     DWORD dwEncoding,
1825     WCHAR* pSrcStr,
1826     UINT* pcSrcSize,
1827     CHAR* pDstStr,
1828     UINT* pcDstSize,
1829     DWORD dwFlag,
1830     WCHAR* lpFallBack)
1831 {
1832     FIXME("\n");
1833     return E_NOTIMPL;
1834 }
1835
1836 static HRESULT WINAPI fnIMultiLanguage2_DetectCodepageInIStream(
1837     IMultiLanguage2* iface,
1838     DWORD dwFlag,
1839     DWORD dwPrefWinCodePage,
1840     IStream* pstmIn,
1841     DetectEncodingInfo* lpEncoding,
1842     INT* pnScores)
1843 {
1844     FIXME("\n");
1845     return E_NOTIMPL;
1846 }
1847
1848 static HRESULT WINAPI fnIMultiLanguage2_DetectInputCodepage(
1849     IMultiLanguage2* iface,
1850     DWORD dwFlag,
1851     DWORD dwPrefWinCodePage,
1852     CHAR* pSrcStr,
1853     INT* pcSrcSize,
1854     DetectEncodingInfo* lpEncoding,
1855     INT* pnScores)
1856 {
1857     FIXME("\n");
1858     return E_NOTIMPL;
1859 }
1860
1861 static HRESULT WINAPI fnIMultiLanguage2_ValidateCodePage(
1862     IMultiLanguage2* iface,
1863     UINT uiCodePage,
1864     HWND hwnd)
1865 {
1866     FIXME("\n");
1867     return E_NOTIMPL;
1868 }
1869
1870 static HRESULT WINAPI fnIMultiLanguage2_GetCodePageDescription(
1871     IMultiLanguage2* iface,
1872     UINT uiCodePage,
1873     LCID lcid,
1874     LPWSTR lpWideCharStr,
1875     int cchWideChar)
1876 {
1877     FIXME("\n");
1878     return E_NOTIMPL;
1879 }
1880
1881 static HRESULT WINAPI fnIMultiLanguage2_IsCodePageInstallable(
1882     IMultiLanguage2* iface,
1883     UINT uiCodePage)
1884 {
1885     FIXME("\n");
1886     return E_NOTIMPL;
1887 }
1888
1889 static HRESULT WINAPI fnIMultiLanguage2_SetMimeDBSource(
1890     IMultiLanguage2* iface,
1891     MIMECONTF dwSource)
1892 {
1893     FIXME("\n");
1894     return E_NOTIMPL;
1895 }
1896
1897 static HRESULT WINAPI fnIMultiLanguage2_GetNumberOfScripts(
1898     IMultiLanguage2* iface,
1899     UINT* pnScripts)
1900 {
1901     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage2, iface);
1902     TRACE("%p %p\n", This, pnScripts);
1903
1904     if (!pnScripts) return S_FALSE;
1905
1906     *pnScripts = This->total_scripts;
1907     return S_OK;
1908 }
1909
1910 static HRESULT WINAPI fnIMultiLanguage2_EnumScripts(
1911     IMultiLanguage2* iface,
1912     DWORD dwFlags,
1913     LANGID LangId,
1914     IEnumScript** ppEnumScript)
1915 {
1916     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage2, iface);
1917     TRACE("%p %08lx %04x %p\n", This, dwFlags, LangId, ppEnumScript);
1918
1919     return EnumScript_create( This, dwFlags, LangId, ppEnumScript );
1920 }
1921
1922 static HRESULT WINAPI fnIMultiLanguage2_ValidateCodePageEx(
1923     IMultiLanguage2* iface,
1924     UINT uiCodePage,
1925     HWND hwnd,
1926     DWORD dwfIODControl)
1927 {
1928     ICOM_THIS_MULTI(MLang_impl, vtbl_IMultiLanguage2, iface);
1929     FIXME("%p %u %p %08lx: stub!\n", This, uiCodePage, hwnd, dwfIODControl);
1930
1931     return S_FALSE;
1932 }
1933
1934 static const IMultiLanguage2Vtbl IMultiLanguage2_vtbl =
1935 {
1936     fnIMultiLanguage2_QueryInterface,
1937     fnIMultiLanguage2_AddRef,
1938     fnIMultiLanguage2_Release,
1939     fnIMultiLanguage2_GetNumberOfCodePageInfo,
1940     fnIMultiLanguage2_GetCodePageInfo,
1941     fnIMultiLanguage2_GetFamilyCodePage,
1942     fnIMultiLanguage2_EnumCodePages,
1943     fnIMultiLanguage2_GetCharsetInfo,
1944     fnIMultiLanguage2_IsConvertible,
1945     fnIMultiLanguage2_ConvertString,
1946     fnIMultiLanguage2_ConvertStringToUnicode,
1947     fnIMultiLanguage2_ConvertStringFromUnicode,
1948     fnIMultiLanguage2_ConvertStringReset,
1949     fnIMultiLanguage2_GetRfc1766FromLcid,
1950     fnIMultiLanguage2_GetLcidFromRfc1766,
1951     fnIMultiLanguage2_EnumRfc1766,
1952     fnIMultiLanguage2_GetRfc1766Info,
1953     fnIMultiLanguage2_CreateConvertCharset,
1954     fnIMultiLanguage2_ConvertStringInIStream,
1955     fnIMultiLanguage2_ConvertStringToUnicodeEx,
1956     fnIMultiLanguage2_ConvertStringFromUnicodeEx,
1957     fnIMultiLanguage2_DetectCodepageInIStream,
1958     fnIMultiLanguage2_DetectInputCodepage,
1959     fnIMultiLanguage2_ValidateCodePage,
1960     fnIMultiLanguage2_GetCodePageDescription,
1961     fnIMultiLanguage2_IsCodePageInstallable,
1962     fnIMultiLanguage2_SetMimeDBSource,
1963     fnIMultiLanguage2_GetNumberOfScripts,
1964     fnIMultiLanguage2_EnumScripts,
1965     fnIMultiLanguage2_ValidateCodePageEx,
1966 };
1967
1968 static HRESULT MultiLanguage_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1969 {
1970     MLang_impl *mlang;
1971     UINT i;
1972
1973     TRACE("Creating MultiLanguage object\n");
1974
1975     if( pUnkOuter )
1976         return CLASS_E_NOAGGREGATION;
1977
1978     mlang = HeapAlloc( GetProcessHeap(), 0, sizeof (MLang_impl) );
1979     mlang->vtbl_IMLangFontLink = &IMLangFontLink_vtbl;
1980     mlang->vtbl_IMultiLanguage = &IMultiLanguage_vtbl;
1981     mlang->vtbl_IMultiLanguage2 = &IMultiLanguage2_vtbl;
1982
1983     mlang->total_cp = 0;
1984     for (i = 0; i < sizeof(mlang_data)/sizeof(mlang_data[0]); i++)
1985         mlang->total_cp += mlang_data[i].number_of_cp;
1986
1987     /* do not enumerate unicode flavours */
1988     mlang->total_scripts = sizeof(mlang_data)/sizeof(mlang_data[0]) - 1;
1989
1990     mlang->ref = 1;
1991     *ppObj = (LPVOID) mlang;
1992     TRACE("returning %p\n", mlang);
1993     return S_OK;
1994 }
1995
1996 /******************************************************************************/
1997
1998 HRESULT WINAPI DllCanUnloadNow(void)
1999 {
2000     FIXME("\n");
2001     return S_FALSE;
2002 }
2003
2004 HRESULT WINAPI GetGlobalFontLinkObject(void)
2005 {
2006     FIXME("\n");
2007     return S_FALSE;
2008 }