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