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