src/msw/mimetype.cpp

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