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