src/msw/mimetype.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/mimetype.cpp
   3 // Purpose:     classes and functions to manage MIME types
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     23.09.98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows license (part of wxExtra library)
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef    __GNUG__
  13 #pragma implementation "mimetype.h"
  14 #endif
  15
  16 // for compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20   #pragma hdrstop
  21 #endif
  22
  23 // this is Win32 only code
  24 #ifndef __WIN16__
  25
  26 #ifndef WX_PRECOMP
  27     #include "wx/string.h"
  28     #if wxUSE_GUI
  29         #include "wx/icon.h"
  30         #include "wx/msgdlg.h"
  31     #endif
  32 #endif //WX_PRECOMP
  33
  34 #include "wx/log.h"
  35 #include "wx/file.h"
  36 #include "wx/intl.h"
  37 #include "wx/dynarray.h"
  38 #include "wx/confbase.h"
  39
  40 #ifdef __WXMSW__
  41     #include "wx/msw/registry.h"
  42     #include "windows.h"
  43 #endif // OS
  44
  45 #include "wx/msw/mimetype.h"
  46
  47 // other standard headers
  48 #include <ctype.h>
  49
  50 // in case we're compiling in non-GUI mode
  51 class WXDLLEXPORT wxIcon;
  52
  53 // These classes use Windows registry to retrieve the required information.
  54 //
  55 // Keys used (not all of them are documented, so it might actually stop working
  56 // in future versions of Windows...):
  57 //  1. "HKCR\MIME\Database\Content Type" contains subkeys for all known MIME
  58 //     types, each key has a string value "Extension" which gives (dot preceded)
  59 //     extension for the files of this MIME type.
  60 //
  61 //  2. "HKCR\.ext" contains
  62 //   a) unnamed value containing the "filetype"
  63 //   b) value "Content Type" containing the MIME type
  64 //
  65 // 3. "HKCR\filetype" contains
  66 //   a) unnamed value containing the description
  67 //   b) subkey "DefaultIcon" with single unnamed value giving the icon index in
  68 //      an icon file
  69 //   c) shell\open\command and shell\open\print subkeys containing the commands
  70 //      to open/print the file (the positional parameters are introduced by %1,
  71 //      %2, ... in these strings, we change them to %s ourselves)
  72
  73 // although I don't know of any official documentation which mentions this
  74 // location, uses it, so it isn't likely to change
  75 static const wxChar *MIME_DATABASE_KEY = wxT("MIME\\Database\\Content Type\\");
  76
  77 void wxFileTypeImpl::Init(const wxString& strFileType, const wxString& ext)
  78 {
  79     // VZ: does it? (FIXME)
  80     wxCHECK_RET( !ext.IsEmpty(), _T("needs an extension") );
  81
  82     if ( ext[0u] != wxT('.') ) {
  83         m_ext = wxT('.');
  84     }
  85     m_ext << ext;
  86
  87     m_strFileType = strFileType;
  88     if ( !strFileType ) {
  89         m_strFileType = m_ext.AfterFirst('.') + "_auto_file";
  90     }
  91 }
  92
  93 wxString wxFileTypeImpl::GetVerbPath(const wxString& verb) const
  94 {
  95     wxString path;
  96     path << m_strFileType << _T("\\shell\\") << verb << _T("\\command");
  97     return path;
  98 }
  99
 100 size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
 101                                       wxArrayString *commands,
 102                                       const wxFileType::MessageParameters& params) const
 103 {
 104     wxCHECK_MSG( !m_ext.IsEmpty(), 0, _T("GetAllCommands() needs an extension") );
 105
 106     if ( m_strFileType.IsEmpty() )
 107     {
 108         // get it from the registry
 109         wxFileTypeImpl *self = wxConstCast(this, wxFileTypeImpl);
 110         wxRegKey rkey(wxRegKey::HKCR, m_ext);
 111         if ( !rkey.Exists() || !rkey.QueryValue(_T(""), self->m_strFileType) )
 112         {
 113             wxLogDebug(_T("Can't get the filetype for extension '%s'."),
 114                        m_ext.c_str());
 115
 116             return 0;
 117         }
 118     }
 119
 120     // enum all subkeys of HKCR\filetype\shell
 121     size_t count = 0;
 122     wxRegKey rkey(wxRegKey::HKCR, m_strFileType  + _T("\\shell"));
 123     long dummy;
 124     wxString verb;
 125     bool ok = rkey.GetFirstKey(verb, dummy);
 126     while ( ok )
 127     {
 128         wxString command = wxFileType::ExpandCommand(GetCommand(verb), params);
 129
 130         // we want the open bverb to eb always the first
 131
 132         if ( verb.CmpNoCase(_T("open")) == 0 )
 133         {
 134             if ( verbs )
 135                 verbs->Insert(verb, 0);
 136             if ( commands )
 137                 commands->Insert(command, 0);
 138         }
 139         else // anything else than "open"
 140         {
 141             if ( verbs )
 142                 verbs->Add(verb);
 143             if ( commands )
 144                 commands->Add(command);
 145         }
 146
 147         count++;
 148
 149         ok = rkey.GetNextKey(verb, dummy);
 150     }
 151
 152     return count;
 153 }
 154
 155 // ----------------------------------------------------------------------------
 156 // modify the registry database
 157 // ----------------------------------------------------------------------------
 158
 159 bool wxFileTypeImpl::EnsureExtKeyExists()
 160 {
 161     wxRegKey rkey(wxRegKey::HKCR, m_ext);
 162     if ( !rkey.Exists() )
 163     {
 164         if ( !rkey.Create() || !rkey.SetValue(_T(""), m_strFileType) )
 165         {
 166             wxLogError(_("Failed to create registry entry for '%s' files."),
 167                        m_ext.c_str());
 168             return FALSE;
 169         }
 170     }
 171
 172     return TRUE;
 173 }
 174
 175 // ----------------------------------------------------------------------------
 176 // get the command to use
 177 // ----------------------------------------------------------------------------
 178
 179 wxString wxFileTypeImpl::GetCommand(const wxChar *verb) const
 180 {
 181     // suppress possible error messages
 182     wxLogNull nolog;
 183     wxString strKey;
 184
 185     if ( wxRegKey(wxRegKey::HKCR, m_ext + _T("\\shell")).Exists() )
 186         strKey = m_ext;
 187     if ( wxRegKey(wxRegKey::HKCR, m_strFileType + _T("\\shell")).Exists() )
 188         strKey = m_strFileType;
 189
 190     if ( !strKey )
 191     {
 192         // no info
 193         return wxEmptyString;
 194     }
 195
 196     strKey << wxT("\\shell\\") << verb;
 197     wxRegKey key(wxRegKey::HKCR, strKey + _T("\\command"));
 198     wxString command;
 199     if ( key.Open() ) {
 200         // it's the default value of the key
 201         if ( key.QueryValue(wxT(""), command) ) {
 202             // transform it from '%1' to '%s' style format string (now also
 203             // test for %L - apparently MS started using it as well for the
 204             // same purpose)
 205
 206             // NB: we don't make any attempt to verify that the string is valid,
 207             //     i.e. doesn't contain %2, or second %1 or .... But we do make
 208             //     sure that we return a string with _exactly_ one '%s'!
 209             bool foundFilename = FALSE;
 210             size_t len = command.Len();
 211             for ( size_t n = 0; (n < len) && !foundFilename; n++ ) {
 212                 if ( command[n] == wxT('%') &&
 213                      (n + 1 < len) &&
 214                      (command[n + 1] == wxT('1') ||
 215                       command[n + 1] == wxT('L')) ) {
 216                     // replace it with '%s'
 217                     command[n + 1] = wxT('s');
 218
 219                     foundFilename = TRUE;
 220                 }
 221             }
 222
 223 #if wxUSE_IPC
 224             // look whether we must issue some DDE requests to the application
 225             // (and not just launch it)
 226             strKey += _T("\\DDEExec");
 227             wxRegKey keyDDE(wxRegKey::HKCR, strKey);
 228             if ( keyDDE.Open() ) {
 229                 wxString ddeCommand, ddeServer, ddeTopic;
 230                 keyDDE.QueryValue(_T(""), ddeCommand);
 231                 ddeCommand.Replace(_T("%1"), _T("%s"));
 232
 233                 wxRegKey(wxRegKey::HKCR, strKey + _T("\\Application")).
 234                     QueryValue(_T(""), ddeServer);
 235                 wxRegKey(wxRegKey::HKCR, strKey + _T("\\Topic")).
 236                     QueryValue(_T(""), ddeTopic);
 237
 238                 // HACK: we use a special feature of wxExecute which exists
 239                 //       just because we need it here: it will establish DDE
 240                 //       conversation with the program it just launched
 241                 command.Prepend(_T("WX_DDE#"));
 242                 command << _T('#') << ddeServer
 243                         << _T('#') << ddeTopic
 244                         << _T('#') << ddeCommand;
 245             }
 246             else
 247 #endif // wxUSE_IPC
 248                 if ( !foundFilename ) {
 249                 // we didn't find any '%1' - the application doesn't know which
 250                 // file to open (note that we only do it if there is no DDEExec
 251                 // subkey)
 252                 //
 253                 // HACK: append the filename at the end, hope that it will do
 254                 command << wxT(" %s");
 255             }
 256         }
 257     }
 258     //else: no such file type or no value, will return empty string
 259
 260     return command;
 261 }
 262
 263 bool
 264 wxFileTypeImpl::GetOpenCommand(wxString *openCmd,
 265                                const wxFileType::MessageParameters& params)
 266                                const
 267 {
 268     wxString cmd = GetCommand(wxT("open"));
 269
 270     *openCmd = wxFileType::ExpandCommand(cmd, params);
 271
 272     return !openCmd->IsEmpty();
 273 }
 274
 275 bool
 276 wxFileTypeImpl::GetPrintCommand(wxString *printCmd,
 277                                 const wxFileType::MessageParameters& params)
 278                                 const
 279 {
 280     wxString cmd = GetCommand(wxT("print"));
 281
 282     *printCmd = wxFileType::ExpandCommand(cmd, params);
 283
 284     return !printCmd->IsEmpty();
 285 }
 286
 287 // ----------------------------------------------------------------------------
 288 // getting other stuff
 289 // ----------------------------------------------------------------------------
 290
 291 // TODO this function is half implemented
 292 bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 293 {
 294     if ( m_ext.IsEmpty() ) {
 295         // the only way to get the list of extensions from the file type is to
 296         // scan through all extensions in the registry - too slow...
 297         return FALSE;
 298     }
 299     else {
 300         extensions.Empty();
 301         extensions.Add(m_ext);
 302
 303         // it's a lie too, we don't return _all_ extensions...
 304         return TRUE;
 305     }
 306 }
 307
 308 bool wxFileTypeImpl::GetMimeType(wxString *mimeType) const
 309 {
 310     // suppress possible error messages
 311     wxLogNull nolog;
 312     wxRegKey key(wxRegKey::HKCR, m_ext);
 313
 314     return key.Open() && key.QueryValue(wxT("Content Type"), *mimeType);
 315 }
 316
 317 bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
 318 {
 319     wxString s;
 320
 321     if ( !GetMimeType(&s) )
 322     {
 323         return FALSE;
 324     }
 325
 326     mimeTypes.Clear();
 327     mimeTypes.Add(s);
 328     return TRUE;
 329 }
 330
 331
 332 bool wxFileTypeImpl::GetIcon(wxIcon *icon,
 333                              wxString *iconFile,
 334                              int *iconIndex) const
 335 {
 336 #if wxUSE_GUI
 337     wxString strIconKey;
 338     strIconKey << m_strFileType << wxT("\\DefaultIcon");
 339
 340     // suppress possible error messages
 341     wxLogNull nolog;
 342     wxRegKey key(wxRegKey::HKCR, strIconKey);
 343
 344     if ( key.Open() ) {
 345         wxString strIcon;
 346         // it's the default value of the key
 347         if ( key.QueryValue(wxT(""), strIcon) ) {
 348             // the format is the following: <full path to file>, <icon index>
 349             // NB: icon index may be negative as well as positive and the full
 350             //     path may contain the environment variables inside '%'
 351             wxString strFullPath = strIcon.BeforeLast(wxT(',')),
 352             strIndex = strIcon.AfterLast(wxT(','));
 353
 354             // index may be omitted, in which case BeforeLast(',') is empty and
 355             // AfterLast(',') is the whole string
 356             if ( strFullPath.IsEmpty() ) {
 357                 strFullPath = strIndex;
 358                 strIndex = wxT("0");
 359             }
 360
 361             wxString strExpPath = wxExpandEnvVars(strFullPath);
 362             // here we need C based counting!
 363             int nIndex = wxAtoi(strIndex);
 364
 365             HICON hIcon = ExtractIcon(GetModuleHandle(NULL), strExpPath, nIndex);
 366             switch ( (int)hIcon ) {
 367                 case 0: // means no icons were found
 368                 case 1: // means no such file or it wasn't a DLL/EXE/OCX/ICO/...
 369                     wxLogDebug(wxT("incorrect registry entry '%s': no such icon."),
 370                                key.GetName().c_str());
 371                     break;
 372
 373                 default:
 374                     icon->SetHICON((WXHICON)hIcon);
 375                     if ( iconIndex )
 376                         *iconIndex = nIndex;
 377                     if ( iconFile )
 378                         *iconFile = strFullPath;
 379                     return TRUE;
 380             }
 381         }
 382     }
 383
 384     // no such file type or no value or incorrect icon entry
 385 #endif // wxUSE_GUI
 386
 387     return FALSE;
 388 }
 389
 390 bool wxFileTypeImpl::GetDescription(wxString *desc) const
 391 {
 392     // suppress possible error messages
 393     wxLogNull nolog;
 394     wxRegKey key(wxRegKey::HKCR, m_strFileType);
 395
 396     if ( key.Open() ) {
 397         // it's the default value of the key
 398         if ( key.QueryValue(wxT(""), *desc) ) {
 399             return TRUE;
 400         }
 401     }
 402
 403     return FALSE;
 404 }
 405
 406 // helper function
 407 wxFileType *
 408 wxMimeTypesManagerImpl::CreateFileType(const wxString& filetype, const wxString& ext)
 409 {
 410     wxFileType *fileType = new wxFileType;
 411     fileType->m_impl->Init(filetype, ext);
 412     return fileType;
 413 }
 414
 415 // extension -> file type
 416 wxFileType *
 417 wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
 418 {
 419     // add the leading point if necessary
 420     wxString str;
 421     if ( ext[0u] != wxT('.') ) {
 422         str = wxT('.');
 423     }
 424     str << ext;
 425
 426     // suppress possible error messages
 427     wxLogNull nolog;
 428
 429     bool knownExtension = FALSE;
 430
 431     wxString strFileType;
 432     wxRegKey key(wxRegKey::HKCR, str);
 433     if ( key.Open() ) {
 434         // it's the default value of the key
 435         if ( key.QueryValue(wxT(""), strFileType) ) {
 436             // create the new wxFileType object
 437             return CreateFileType(strFileType, ext);
 438         }
 439         else {
 440             // this extension doesn't have a filetype, but it's known to the
 441             // system and may be has some other useful keys (open command or
 442             // content-type), so still return a file type object for it
 443             knownExtension = TRUE;
 444         }
 445     }
 446
 447     if ( !knownExtension )
 448     {
 449         // unknown extension
 450         return NULL;
 451     }
 452
 453     return CreateFileType(wxEmptyString, ext);
 454 }
 455
 456 /*
 457 wxFileType *
 458 wxMimeTypesManagerImpl::GetOrAllocateFileTypeFromExtension(const wxString& ext)
 459 {
 460     wxFileType *fileType = GetFileTypeFromExtension(ext);
 461     if ( !fileType )
 462     {
 463         fileType = CreateFileType(wxEmptyString, ext);
 464     }
 465
 466     return fileType;
 467 }
 468 */
 469
 470 // MIME type -> extension -> file type
 471 wxFileType *
 472 wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 473 {
 474     wxString strKey = MIME_DATABASE_KEY;
 475     strKey << mimeType;
 476
 477     // suppress possible error messages
 478     wxLogNull nolog;
 479
 480     wxString ext;
 481     wxRegKey key(wxRegKey::HKCR, strKey);
 482     if ( key.Open() ) {
 483         if ( key.QueryValue(wxT("Extension"), ext) ) {
 484             return GetFileTypeFromExtension(ext);
 485         }
 486     }
 487
 488     // unknown MIME type
 489     return NULL;
 490 }
 491
 492 size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 493 {
 494     // enumerate all keys under MIME_DATABASE_KEY
 495     wxRegKey key(wxRegKey::HKCR, MIME_DATABASE_KEY);
 496
 497     wxString type;
 498     long cookie;
 499     bool cont = key.GetFirstKey(type, cookie);
 500     while ( cont )
 501     {
 502         mimetypes.Add(type);
 503
 504         cont = key.GetNextKey(type, cookie);
 505     }
 506
 507     return mimetypes.GetCount();
 508 }
 509
 510 // ----------------------------------------------------------------------------
 511 // create a new association
 512 // ----------------------------------------------------------------------------
 513
 514 wxFileType *wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
 515 {
 516     wxCHECK_MSG( !ftInfo.GetExtensions().IsEmpty(), NULL,
 517                  _T("Associate() needs extension") );
 518
 519     bool ok = FALSE ;
 520     int iExtCount = 0 ;
 521     wxString filetype;
 522     wxString extWithDot;
 523
 524     wxString ext = ftInfo.GetExtensions()[iExtCount];
 525
 526     wxCHECK_MSG( !ext.empty(), NULL,
 527                  _T("Associate() needs non empty extension") );
 528
 529     if ( ext[0u] != _T('.') )
 530         extWithDot = _T('.');
 531     extWithDot += ext;
 532
 533     // start by setting the HKCR\\.ext entries
 534     // default is filetype; content type is mimetype
 535     const wxString& filetypeOrig = ftInfo.GetShortDesc();
 536
 537     wxRegKey key(wxRegKey::HKCR, extWithDot);
 538     if ( !key.Exists() )
 539     {
 540         // create the mapping from the extension to the filetype
 541         ok = key.Create();
 542         if ( ok )
 543         {
 544
 545             if ( filetypeOrig.empty() )
 546             {
 547                 // make it up from the extension
 548                 filetype << extWithDot.c_str() + 1 << _T("_file");
 549             }
 550             else
 551             {
 552                 // just use the provided one
 553                 filetype = filetypeOrig;
 554             }
 555
 556             ok = key.SetValue(_T(""), filetype);
 557         }
 558         }
 559         else
 560         {
 561             // key already exists, maybe we want to change it ??
 562             if (!filetypeOrig.empty())
 563                 {
 564                     filetype = filetypeOrig;
 565                     ok = key.SetValue(_T(""), filetype);
 566                 }
 567             else
 568                 {
 569                     ok = key.QueryValue(_T(""), filetype);
 570                 }
 571         }
 572         // now set a mimetypeif we have it, but ignore it if none
 573         const wxString& mimetype = ftInfo.GetMimeType();
 574         if ( !mimetype.empty() )
 575         {
 576             // set the MIME type
 577             ok = key.SetValue(_T("Content Type"), mimetype);
 578
 579             if ( ok )
 580             {
 581                 // create the MIME key
 582                 wxString strKey = MIME_DATABASE_KEY;
 583                 strKey << mimetype;
 584                 wxRegKey keyMIME(wxRegKey::HKCR, strKey);
 585                 ok = keyMIME.Create();
 586
 587                 if ( ok )
 588                 {
 589                     // and provide a back link to the extension
 590                     ok = keyMIME.SetValue(_T("Extension"), extWithDot);
 591                 }
 592             }
 593         }
 594
 595
 596     // now make other extensions have the same filetype
 597
 598     for (iExtCount=1; iExtCount < ftInfo.GetExtensionsCount(); iExtCount++ )
 599         {
 600             ext = ftInfo.GetExtensions()[iExtCount];
 601             if ( ext[0u] != _T('.') )
 602                extWithDot = _T('.');
 603             extWithDot += ext;
 604
 605             wxRegKey key(wxRegKey::HKCR, extWithDot);
 606             if ( !key.Exists() ) ok = key.Create();
 607             ok = key.SetValue(_T(""), filetype);
 608
 609         // now set any mimetypes we may have, but ignore it if none
 610         const wxString& mimetype = ftInfo.GetMimeType();
 611         if ( !mimetype.empty() )
 612         {
 613             // set the MIME type
 614             ok = key.SetValue(_T("Content Type"), mimetype);
 615
 616         if ( ok )
 617         {
 618                 // create the MIME key
 619                 wxString strKey = MIME_DATABASE_KEY;
 620                 strKey << mimetype;
 621                 wxRegKey keyMIME(wxRegKey::HKCR, strKey);
 622                 ok = keyMIME.Create();
 623
 624         if ( ok )
 625         {
 626                     // and provide a back link to the extension
 627                     ok = keyMIME.SetValue(_T("Extension"), extWithDot);
 628         }
 629         }
 630     }
 631
 632
 633     } // end of for loop; all extensions now point to HKCR\.ext\Default
 634
 635     // create the filetype key itself (it will be empty for now, but
 636     // SetCommand(), SetDefaultIcon() &c will use it later)
 637     wxRegKey keyFT(wxRegKey::HKCR, filetype);
 638     ok = keyFT.Create();
 639
 640     wxFileType *ft = NULL;
 641     ft = CreateFileType(filetype, extWithDot);
 642
 643     if (ft)
 644     {
 645             if (! ftInfo.GetOpenCommand ().IsEmpty() ) ft->SetCommand (ftInfo.GetOpenCommand (), wxT("open"  ) );
 646             if (! ftInfo.GetPrintCommand().IsEmpty() ) ft->SetCommand (ftInfo.GetPrintCommand(), wxT("print" ) );
 647             // chris: I don't like the ->m_impl-> here FIX this ??
 648             if (! ftInfo.GetDescription ().IsEmpty() ) ft->m_impl->SetDescription (ftInfo.GetDescription ()) ;
 649             if (! ftInfo.GetIconFile().IsEmpty() ) ft->SetDefaultIcon (ftInfo.GetIconFile(), ftInfo.GetIconIndex() );
 650
 651         }
 652     return ft;
 653 }
 654
 655 bool wxFileTypeImpl::SetCommand(const wxString& cmd,
 656                                 const wxString& verb,
 657                                 bool overwriteprompt)
 658 {
 659     wxCHECK_MSG( !m_ext.IsEmpty() && !verb.IsEmpty(), FALSE,
 660                  _T("SetCommand() needs an extension and a verb") );
 661
 662     if ( !EnsureExtKeyExists() )
 663         return FALSE;
 664
 665     wxRegKey rkey(wxRegKey::HKCR, GetVerbPath(verb));
 666 #if 0
 667     if ( rkey.Exists() && overwriteprompt )
 668     {
 669 #if wxUSE_GUI
 670         wxString old;
 671         rkey.QueryValue(wxT(""), old);
 672         if ( wxMessageBox
 673              (
 674                 wxString::Format(
 675                     _("Do you want to overwrite the command used to %s "
 676                       "files with extension \"%s\" ?\nCurrent value is \n%s, "
 677                       "\nNew value is \n%s %1"), // bug here FIX need %1 ??
 678                     verb.c_str(),
 679                     m_ext.c_str(),
 680                     old.c_str(),
 681                     cmd.c_str()),
 682                 _("Confirm registry update"),
 683                 wxYES_NO | wxICON_QUESTION
 684              ) != wxYES )
 685 #endif // wxUSE_GUI
 686         {
 687             // cancelled by user
 688             return FALSE;
 689         }
 690     }
 691 #endif
 692     // TODO:
 693     // 1. translate '%s' to '%1' instead of always adding it
 694     // 2. create DDEExec value if needed (undo GetCommand)
 695     return rkey.Create() && rkey.SetValue(_T(""), cmd + _T(" \"%1\"") );
 696 }
 697
 698 /* // no longer used
 699 bool wxFileTypeImpl::SetMimeType(const wxString& mimeTypeOrig)
 700 {
 701     wxCHECK_MSG( !m_ext.IsEmpty(), FALSE, _T("SetMimeType() needs extension") );
 702
 703     if ( !EnsureExtKeyExists() )
 704         return FALSE;
 705
 706     // VZ: is this really useful? (FIXME)
 707     wxString mimeType;
 708     if ( !mimeTypeOrig )
 709     {
 710         // make up a default value for it
 711         wxString cmd;
 712         wxSplitPath(GetCommand(_T("open")), NULL, &cmd, NULL);
 713         mimeType << _T("application/x-") << cmd;
 714     }
 715     else
 716     {
 717         mimeType = mimeTypeOrig;
 718     }
 719
 720     wxRegKey rkey(wxRegKey::HKCR, m_ext);
 721     return rkey.Create() && rkey.SetValue(_T("Content Type"), mimeType);
 722 }
 723 */
 724
 725 bool wxFileTypeImpl::SetDefaultIcon(const wxString& cmd, int index)
 726 {
 727     wxCHECK_MSG( !m_ext.IsEmpty(), FALSE, _T("SetDefaultIcon() needs extension") );
 728     wxCHECK_MSG( !m_strFileType.IsEmpty(), FALSE, _T("File key not found") );
 729 //    the next line fails on a SMBshare, I think because it is case mangled
 730 //    wxCHECK_MSG( !wxFileExists(cmd), FALSE, _T("Icon file not found.") );
 731
 732     if ( !EnsureExtKeyExists() )
 733         return FALSE;
 734
 735     wxRegKey rkey(wxRegKey::HKCR, m_strFileType + _T("\\DefaultIcon"));
 736
 737     return rkey.Create() &&
 738            rkey.SetValue(_T(""),
 739                          wxString::Format(_T("%s,%d"), cmd.c_str(), index));
 740 }
 741
 742 bool wxFileTypeImpl::SetDescription (const wxString& desc)
 743 {
 744     wxCHECK_MSG( !m_strFileType.IsEmpty(), FALSE, _T("File key not found") );
 745     wxCHECK_MSG( !desc.IsEmpty(), FALSE, _T("No file description supplied") );
 746
 747     if ( !EnsureExtKeyExists() )
 748         return FALSE;
 749
 750     wxRegKey rkey(wxRegKey::HKCR, m_strFileType );
 751
 752     return rkey.Create() &&
 753            rkey.SetValue(_T(""), desc);
 754 }
 755
 756 // ----------------------------------------------------------------------------
 757 // remove file association
 758 // ----------------------------------------------------------------------------
 759
 760 bool wxFileTypeImpl::Unassociate()
 761 {
 762     bool result = TRUE;
 763     if ( !RemoveOpenCommand() )
 764         result = FALSE;
 765     if ( !RemoveDefaultIcon() )
 766         result = FALSE;
 767     if ( !RemoveMimeType() )
 768         result = FALSE;
 769    if ( !RemoveDescription() )
 770         result = FALSE;
 771
 772 /*
 773     //this might hold other keys, eg some have CSLID keys
 774     if ( result )
 775     {
 776         // delete the root key
 777         wxRegKey key(wxRegKey::HKCR, m_ext);
 778         if ( key.Exists() )
 779             result = key.DeleteSelf();
 780     }
 781 */
 782     return result;
 783 }
 784
 785 bool wxFileTypeImpl::RemoveOpenCommand()
 786 {
 787    return RemoveCommand(_T("open"));
 788 }
 789
 790 bool wxFileTypeImpl::RemoveCommand(const wxString& verb)
 791 {
 792     wxCHECK_MSG( !m_ext.IsEmpty() && !verb.IsEmpty(), FALSE,
 793                  _T("RemoveCommand() needs an extension and a verb") );
 794
 795     wxString  sKey = m_strFileType;
 796     wxRegKey rkey(wxRegKey::HKCR, GetVerbPath(verb));
 797
 798     // if the key already doesn't exist, it's a success
 799     return !rkey.Exists() || rkey.DeleteSelf();
 800 }
 801
 802 bool wxFileTypeImpl::RemoveMimeType()
 803 {
 804     wxCHECK_MSG( !m_ext.IsEmpty(), FALSE, _T("RemoveMimeType() needs extension") );
 805
 806     wxRegKey rkey(wxRegKey::HKCR, m_ext);
 807     return !rkey.Exists() || rkey.DeleteSelf();
 808 }
 809
 810 bool wxFileTypeImpl::RemoveDefaultIcon()
 811 {
 812     wxCHECK_MSG( !m_ext.IsEmpty(), FALSE,
 813                  _T("RemoveDefaultIcon() needs extension") );
 814
 815     wxRegKey rkey (wxRegKey::HKCR, m_strFileType  + _T("\\DefaultIcon"));
 816     return !rkey.Exists() || rkey.DeleteSelf();
 817 }
 818
 819 bool wxFileTypeImpl::RemoveDescription()
 820 {
 821     wxCHECK_MSG( !m_ext.IsEmpty(), FALSE,
 822                  _T("RemoveDescription() needs extension") );
 823
 824     wxRegKey rkey (wxRegKey::HKCR, m_strFileType );
 825     return !rkey.Exists() || rkey.DeleteSelf();
 826 }
 827
 828 #endif
 829   // __WIN16__