src/unix/mimetype.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/unix/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 licence (part of wxExtra library)
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // for compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_MIMETYPE && wxUSE_FILE
  20
  21 #include "wx/unix/mimetype.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/dynarray.h"
  25     #include "wx/string.h"
  26     #include "wx/intl.h"
  27     #include "wx/log.h"
  28     #include "wx/utils.h"
  29 #endif
  30
  31 #include "wx/file.h"
  32 #include "wx/confbase.h"
  33
  34 #include "wx/ffile.h"
  35 #include "wx/dir.h"
  36 #include "wx/tokenzr.h"
  37 #include "wx/iconloc.h"
  38 #include "wx/filename.h"
  39 #include "wx/app.h"
  40 #include "wx/apptrait.h"
  41
  42 // other standard headers
  43 #include <ctype.h>
  44
  45 class wxMimeTextFile
  46 {
  47 public:
  48     wxMimeTextFile()
  49     {
  50     }
  51
  52     wxMimeTextFile(const wxString& fname)
  53     {
  54        m_fname = fname;
  55     }
  56
  57     bool Open()
  58     {
  59        wxFFile file( m_fname );
  60        if (!file.IsOpened())
  61           return false;
  62
  63        size_t size = file.Length();
  64        wxCharBuffer buffer( size );
  65        file.Read( (void*) (const char*) buffer, size );
  66
  67        // Check for valid UTF-8 here?
  68        wxString all = wxString::FromUTF8( buffer, size );
  69
  70        wxStringTokenizer tok( all, "\n" );
  71        while (tok.HasMoreTokens())
  72        {
  73           wxString t = tok.GetNextToken();
  74           t.MakeLower();
  75           if ((!!t) && (t.Find( "comment" ) != 0) && (t.Find( "#" ) != 0) && (t.Find( "generic" ) != 0))
  76              m_text.Add( t );
  77        }
  78        return true;
  79     }
  80
  81     unsigned int GetLineCount() const { return m_text.GetCount(); }
  82     wxString &GetLine( unsigned int line ) { return m_text[line]; }
  83
  84     int pIndexOf(const wxString& sSearch,
  85                  bool bIncludeComments = false,
  86                  int iStart = 0)
  87     {
  88         wxString sTest = sSearch;
  89         sTest.MakeLower();
  90         for(size_t i = iStart; i < GetLineCount(); i++)
  91         {
  92             wxString sLine = GetLine(i);
  93             if(bIncludeComments || ! sLine.StartsWith(wxT("#")))
  94             {
  95                 if(sLine.StartsWith(sTest))
  96                     return (int)i;
  97             }
  98         }
  99         return wxNOT_FOUND;
 100     }
 101
 102     wxString GetVerb(size_t i)
 103     {
 104         if (i > GetLineCount() )
 105             return wxEmptyString;
 106
 107         wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
 108         return sTmp;
 109     }
 110
 111     wxString GetCmd(size_t i)
 112     {
 113         if (i > GetLineCount() )
 114             return wxEmptyString;
 115
 116         wxString sTmp = GetLine(i).AfterFirst(wxT('='));
 117         return sTmp;
 118     }
 119
 120 private:
 121     wxArrayString m_text;
 122     wxString m_fname;
 123 };
 124
 125 // ----------------------------------------------------------------------------
 126 // constants
 127 // ----------------------------------------------------------------------------
 128
 129 // MIME code tracing mask
 130 #define TRACE_MIME wxT("mime")
 131
 132
 133 // Read a XDG *.desktop file of type 'Application'
 134 void wxMimeTypesManagerImpl::LoadXDGApp(const wxString& filename)
 135 {
 136     wxLogTrace(TRACE_MIME, wxT("loading XDG file %s"), filename.c_str());
 137
 138     wxMimeTextFile file(filename);
 139     if ( !file.Open() )
 140         return;
 141
 142     // Here, only type 'Application' should be considered.
 143     int nIndex = file.pIndexOf( "Type=" );
 144     if (nIndex != wxNOT_FOUND && file.GetCmd(nIndex) != "application")
 145         return;
 146
 147     // The hidden entry specifies a file to be ignored.
 148     nIndex = file.pIndexOf( "Hidden=" );
 149     if (nIndex != wxNOT_FOUND && file.GetCmd(nIndex) == "true")
 150         return;
 151
 152     // Semicolon separated list of mime types handled by the application.
 153     nIndex = file.pIndexOf( wxT("MimeType=") );
 154     if (nIndex == wxNOT_FOUND)
 155         return;
 156     wxString mimetypes = file.GetCmd (nIndex);
 157
 158     // Name of the application
 159     wxString nameapp;
 160     nIndex = wxNOT_FOUND;
 161 #if wxUSE_INTL // try "Name[locale name]" first
 162     wxLocale *locale = wxGetLocale();
 163     if ( locale )
 164         nIndex = file.pIndexOf(wxT("Name[")+locale->GetName()+wxT("]="));
 165 #endif // wxUSE_INTL
 166     if(nIndex == wxNOT_FOUND)
 167         nIndex = file.pIndexOf( wxT("Name=") );
 168     if(nIndex != wxNOT_FOUND)
 169         nameapp = file.GetCmd(nIndex);
 170
 171     // Icon of the application.
 172     wxString nameicon, namemini;
 173     nIndex = wxNOT_FOUND;
 174 #if wxUSE_INTL // try "Icon[locale name]" first
 175     if ( locale )
 176         nIndex = file.pIndexOf(wxT("Icon[")+locale->GetName()+wxT("]="));
 177 #endif // wxUSE_INTL
 178     if(nIndex == wxNOT_FOUND)
 179         nIndex = file.pIndexOf( wxT("Icon=") );
 180     if(nIndex != wxNOT_FOUND) {
 181         nameicon = wxString(wxT("--icon ")) + file.GetCmd(nIndex);
 182         namemini = wxString(wxT("--miniicon ")) + file.GetCmd(nIndex);
 183     }
 184
 185     // Replace some of the field code in the 'Exec' entry.
 186     // TODO: deal with %d, %D, %n, %N, %k and %v (but last one is deprecated)
 187     nIndex = file.pIndexOf( wxT("Exec=") );
 188     if (nIndex == wxNOT_FOUND)
 189         return;
 190     wxString sCmd = file.GetCmd(nIndex);
 191     // we expect %f; others including  %F and %U and %u are possible
 192     sCmd.Replace(wxT("%F"), wxT("%f"));
 193     sCmd.Replace(wxT("%U"), wxT("%f"));
 194     sCmd.Replace(wxT("%u"), wxT("%f"));
 195     if (0 == sCmd.Replace ( wxT("%f"), wxT("%s") ))
 196         sCmd = sCmd + wxT(" %s");
 197     sCmd.Replace(wxT("%c"), nameapp);
 198     sCmd.Replace(wxT("%i"), nameicon);
 199     sCmd.Replace(wxT("%m"), namemini);
 200
 201     wxStringTokenizer tokenizer(mimetypes, wxT(";"));
 202     while(tokenizer.HasMoreTokens()) {
 203         wxString mimetype = tokenizer.GetNextToken().Lower();
 204         nIndex = m_aTypes.Index(mimetype);
 205         if(nIndex != wxNOT_FOUND) { // is this a known MIME type?
 206             wxMimeTypeCommands* entry = m_aEntries[nIndex];
 207             entry->AddOrReplaceVerb(wxT("open"), sCmd);
 208         }
 209     }
 210 }
 211
 212 void wxMimeTypesManagerImpl::LoadXDGAppsFilesFromDir(const wxString& dirname)
 213 {
 214     // Don't complain if we don't have permissions to read - it confuses users
 215     wxLogNull logNull;
 216
 217     if(! wxDir::Exists(dirname))
 218         return;
 219     wxDir dir(dirname);
 220     if ( !dir.IsOpened() )
 221         return;
 222
 223     wxString filename;
 224     // Look into .desktop files
 225     bool cont = dir.GetFirst(&filename, wxT("*.desktop"), wxDIR_FILES);
 226     while (cont)
 227     {
 228         wxFileName p(dirname, filename);
 229         LoadXDGApp( p.GetFullPath() );
 230         cont = dir.GetNext(&filename);
 231     }
 232
 233 #if 0
 234     // RR: I'm not sure this makes any sense. On my system we'll just
 235     //     scan the YAST2 and other useless directories
 236
 237     // Look recursively into subdirs
 238     cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
 239     while (cont)
 240     {
 241         wxFileName p(dirname, wxEmptyString);
 242         p.AppendDir(filename);
 243         LoadXDGAppsFilesFromDir( p.GetPath() );
 244         cont = dir.GetNext(&filename);
 245     }
 246 #endif
 247 }
 248
 249
 250 void wxMimeTypesManagerImpl::LoadXDGGlobs(const wxString& filename)
 251 {
 252     if ( !wxFileName::FileExists(filename) )
 253         return;
 254
 255     wxLogTrace(TRACE_MIME, wxT("loading XDG globs file from %s"), filename.c_str());
 256
 257     wxMimeTextFile file(filename);
 258     if ( !file.Open() )
 259         return;
 260
 261     size_t i;
 262     for (i = 0; i < file.GetLineCount(); i++)
 263     {
 264        wxStringTokenizer tok( file.GetLine(i), ":" );
 265        wxString mime = tok.GetNextToken();
 266        wxString ext = tok.GetNextToken();
 267        ext.Remove( 0, 2 );
 268        wxArrayString exts;
 269        exts.Add( ext );
 270
 271        AddToMimeData(mime, wxEmptyString, NULL, exts, wxEmptyString, true );
 272     }
 273 }
 274
 275 // ----------------------------------------------------------------------------
 276 // wxFileTypeImpl (Unix)
 277 // ----------------------------------------------------------------------------
 278
 279 wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileType::MessageParameters& params) const
 280 {
 281     wxString sTmp;
 282     size_t i = 0;
 283     while ( (i < m_index.GetCount() ) && sTmp.empty() )
 284     {
 285         sTmp = m_manager->GetCommand( verb, m_index[i] );
 286         i++;
 287     }
 288
 289     return wxFileType::ExpandCommand(sTmp, params);
 290 }
 291
 292 bool wxFileTypeImpl::GetIcon(wxIconLocation *iconLoc) const
 293 {
 294     wxString sTmp;
 295     size_t i = 0;
 296     while ( (i < m_index.GetCount() ) && sTmp.empty() )
 297     {
 298         sTmp = m_manager->m_aIcons[m_index[i]];
 299         i++;
 300     }
 301
 302     if ( sTmp.empty() )
 303         return false;
 304
 305     if ( iconLoc )
 306     {
 307         iconLoc->SetFileName(sTmp);
 308     }
 309
 310     return true;
 311 }
 312
 313 bool wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
 314 {
 315     mimeTypes.Clear();
 316     size_t nCount = m_index.GetCount();
 317     for (size_t i = 0; i < nCount; i++)
 318         mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);
 319
 320     return true;
 321 }
 322
 323 size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
 324                                   wxArrayString *commands,
 325                                   const wxFileType::MessageParameters& params) const
 326 {
 327     wxString vrb, cmd, sTmp;
 328     size_t count = 0;
 329     wxMimeTypeCommands * sPairs;
 330
 331     // verbs and commands have been cleared already in mimecmn.cpp...
 332     // if we find no entries in the exact match, try the inexact match
 333     for (size_t n = 0; ((count == 0) && (n < m_index.GetCount())); n++)
 334     {
 335         // list of verb = command pairs for this mimetype
 336         sPairs = m_manager->m_aEntries [m_index[n]];
 337         size_t i;
 338         for ( i = 0; i < sPairs->GetCount(); i++ )
 339         {
 340             vrb = sPairs->GetVerb(i);
 341             // some gnome entries have "." inside
 342             vrb = vrb.AfterLast(wxT('.'));
 343             cmd = sPairs->GetCmd(i);
 344             if (! cmd.empty() )
 345             {
 346                  cmd = wxFileType::ExpandCommand(cmd, params);
 347                  count++;
 348                  if ( vrb.IsSameAs(wxT("open")))
 349                  {
 350                      if ( verbs )
 351                         verbs->Insert(vrb, 0u);
 352                      if ( commands )
 353                         commands ->Insert(cmd, 0u);
 354                  }
 355                  else
 356                  {
 357                      if ( verbs )
 358                         verbs->Add(vrb);
 359                      if ( commands )
 360                         commands->Add(cmd);
 361                  }
 362              }
 363         }
 364     }
 365
 366     return count;
 367 }
 368
 369 bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
 370 {
 371     const wxString strExtensions = m_manager->GetExtension(m_index[0]);
 372     extensions.Empty();
 373
 374     // one extension in the space or comma-delimited list
 375     wxString strExt;
 376     wxString::const_iterator end = strExtensions.end();
 377     for ( wxString::const_iterator p = strExtensions.begin(); /* nothing */; ++p )
 378     {
 379         if ( p == end || *p == wxT(' ') || *p == wxT(',') )
 380         {
 381             if ( !strExt.empty() )
 382             {
 383                 extensions.Add(strExt);
 384                 strExt.Empty();
 385             }
 386             //else: repeated spaces
 387             // (shouldn't happen, but it's not that important if it does happen)
 388
 389             if ( p == end )
 390                 break;
 391         }
 392         else if ( *p == wxT('.') )
 393         {
 394             // remove the dot from extension (but only if it's the first char)
 395             if ( !strExt.empty() )
 396             {
 397                 strExt += wxT('.');
 398             }
 399             //else: no, don't append it
 400         }
 401         else
 402         {
 403             strExt += *p;
 404         }
 405     }
 406
 407     return true;
 408 }
 409
 410 // set an arbitrary command:
 411 // could adjust the code to ask confirmation if it already exists and
 412 // overwriteprompt is true, but this is currently ignored as *Associate* has
 413 // no overwrite prompt
 414 bool
 415 wxFileTypeImpl::SetCommand(const wxString& cmd,
 416                            const wxString& verb,
 417                            bool WXUNUSED(overwriteprompt))
 418 {
 419     wxArrayString strExtensions;
 420     wxString strDesc, strIcon;
 421
 422     wxArrayString strTypes;
 423     GetMimeTypes(strTypes);
 424     if ( strTypes.IsEmpty() )
 425         return false;
 426
 427     wxMimeTypeCommands *entry = new wxMimeTypeCommands();
 428     entry->Add(verb + wxT("=")  + cmd + wxT(" %s "));
 429
 430     bool ok = false;
 431     size_t nCount = strTypes.GetCount();
 432     for ( size_t i = 0; i < nCount; i++ )
 433     {
 434         if ( m_manager->DoAssociation
 435                         (
 436                             strTypes[i],
 437                             strIcon,
 438                             entry,
 439                             strExtensions,
 440                             strDesc
 441                         ) )
 442         {
 443             // DoAssociation() took ownership of entry, don't delete it below
 444             ok = true;
 445         }
 446     }
 447
 448     if ( !ok )
 449         delete entry;
 450
 451     return ok;
 452 }
 453
 454 // ignore index on the grounds that we only have one icon in a Unix file
 455 bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon, int WXUNUSED(index))
 456 {
 457     if (strIcon.empty())
 458         return false;
 459
 460     wxArrayString strExtensions;
 461     wxString strDesc;
 462
 463     wxArrayString strTypes;
 464     GetMimeTypes(strTypes);
 465     if ( strTypes.IsEmpty() )
 466         return false;
 467
 468     wxMimeTypeCommands *entry = new wxMimeTypeCommands();
 469     bool ok = false;
 470     size_t nCount = strTypes.GetCount();
 471     for ( size_t i = 0; i < nCount; i++ )
 472     {
 473         if ( m_manager->DoAssociation
 474                         (
 475                             strTypes[i],
 476                             strIcon,
 477                             entry,
 478                             strExtensions,
 479                             strDesc
 480                         ) )
 481         {
 482             // we don't need to free entry now, DoAssociation() took ownership
 483             // of it
 484             ok = true;
 485         }
 486     }
 487
 488     if ( !ok )
 489         delete entry;
 490
 491     return ok;
 492 }
 493
 494 // ----------------------------------------------------------------------------
 495 // wxMimeTypesManagerImpl (Unix)
 496 // ----------------------------------------------------------------------------
 497
 498 wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
 499 {
 500     m_initialized = false;
 501 }
 502
 503 void wxMimeTypesManagerImpl::InitIfNeeded()
 504 {
 505     if ( !m_initialized )
 506     {
 507         // set the flag first to prevent recursion
 508         m_initialized = true;
 509
 510         int mailcapStyles = wxMAILCAP_ALL;
 511         if ( wxAppTraits * const traits = wxApp::GetTraitsIfExists() )
 512         {
 513             wxString wm = traits->GetDesktopEnvironment();
 514
 515             if ( wm == "KDE" )
 516                 mailcapStyles = wxMAILCAP_KDE;
 517             else if ( wm == "GNOME" )
 518                 mailcapStyles = wxMAILCAP_GNOME;
 519             //else: unknown, use the default
 520         }
 521
 522         Initialize(mailcapStyles);
 523     }
 524 }
 525
 526
 527
 528 // read system and user mailcaps and other files
 529 void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
 530                                         const wxString& sExtraDir)
 531 {
 532 #ifdef __VMS
 533     // XDG tables are never installed on OpenVMS
 534     return;
 535 #else
 536
 537     // Read MIME type - extension associations
 538     LoadXDGGlobs( "/usr/share/mime/globs" );
 539     LoadXDGGlobs( "/usr/local/share/mime/globs" );
 540
 541     // Load desktop files for XDG, and then override them with the defaults.
 542     // We will override them one desktop file at a time, rather
 543     // than one mime type at a time, but it should be a reasonable
 544     // heuristic.
 545     {
 546         wxString xdgDataHome = wxGetenv("XDG_DATA_HOME");
 547         if ( xdgDataHome.empty() )
 548             xdgDataHome = wxGetHomeDir() + "/.local/share";
 549         wxString xdgDataDirs = wxGetenv("XDG_DATA_DIRS");
 550         if ( xdgDataDirs.empty() )
 551         {
 552             xdgDataDirs = "/usr/local/share:/usr/share";
 553             if (mailcapStyles & wxMAILCAP_GNOME)
 554                 xdgDataDirs += ":/usr/share/gnome:/opt/gnome/share";
 555             if (mailcapStyles & wxMAILCAP_KDE)
 556                 xdgDataDirs += ":/usr/share/kde3:/opt/kde3/share";
 557         }
 558         if ( !sExtraDir.empty() )
 559         {
 560            xdgDataDirs += ':';
 561            xdgDataDirs += sExtraDir;
 562         }
 563
 564         wxArrayString dirs;
 565         wxStringTokenizer tokenizer(xdgDataDirs, ":");
 566         while ( tokenizer.HasMoreTokens() )
 567         {
 568             wxString p = tokenizer.GetNextToken();
 569             dirs.Add(p);
 570         }
 571         dirs.insert(dirs.begin(), xdgDataHome);
 572
 573         wxString defaultsList;
 574         size_t i;
 575         for (i = 0; i < dirs.GetCount(); i++)
 576         {
 577             wxString f = dirs[i];
 578             if (f.Last() != '/') f += '/';
 579             f += "applications/defaults.list";
 580             if (wxFileExists(f))
 581             {
 582                 defaultsList = f;
 583                 break;
 584             }
 585         }
 586
 587         // Load application files and associate them to corresponding mime types.
 588         size_t nDirs = dirs.GetCount();
 589         for (size_t nDir = 0; nDir < nDirs; nDir++)
 590         {
 591             wxString dirStr = dirs[nDir];
 592             if (dirStr.Last() != '/') dirStr += '/';
 593             dirStr += "applications";
 594             LoadXDGAppsFilesFromDir(dirStr);
 595         }
 596
 597         if (!defaultsList.IsEmpty())
 598         {
 599             wxArrayString deskTopFilesSeen;
 600
 601             wxMimeTextFile textfile(defaultsList);
 602             if ( textfile.Open() )
 603             {
 604                 int nIndex = textfile.pIndexOf( wxT("[Default Applications]") );
 605                 if (nIndex != wxNOT_FOUND)
 606                 {
 607                     for (i = nIndex+1; i < textfile.GetLineCount(); i++)
 608                     {
 609                         if (textfile.GetLine(i).Find(wxT("=")) != wxNOT_FOUND)
 610                         {
 611                             wxString desktopFile = textfile.GetCmd(i);
 612
 613                             if (deskTopFilesSeen.Index(desktopFile) == wxNOT_FOUND)
 614                             {
 615                                 deskTopFilesSeen.Add(desktopFile);
 616                                 size_t j;
 617                                 for (j = 0; j < dirs.GetCount(); j++)
 618                                 {
 619                                     wxString desktopPath = dirs[j];
 620                                     if (desktopPath.Last() != '/') desktopPath += '/';
 621                                     desktopPath += "applications/";
 622                                     desktopPath += desktopFile;
 623
 624                                     if (wxFileExists(desktopPath))
 625                                         LoadXDGApp(desktopPath);
 626                                 }
 627                             }
 628                         }
 629                     }
 630                 }
 631             }
 632         }
 633     }
 634 #endif
 635 }
 636
 637 // clear data so you can read another group of WM files
 638 void wxMimeTypesManagerImpl::ClearData()
 639 {
 640     m_aTypes.Clear();
 641     m_aIcons.Clear();
 642     m_aExtensions.Clear();
 643     m_aDescriptions.Clear();
 644
 645     WX_CLEAR_ARRAY(m_aEntries);
 646     m_aEntries.Empty();
 647 }
 648
 649 wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
 650 {
 651     ClearData();
 652 }
 653
 654 wxFileType * wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
 655 {
 656     InitIfNeeded();
 657
 658     wxString strType = ftInfo.GetMimeType();
 659     wxString strDesc = ftInfo.GetDescription();
 660     wxString strIcon = ftInfo.GetIconFile();
 661
 662     wxMimeTypeCommands *entry = new wxMimeTypeCommands();
 663
 664     if ( ! ftInfo.GetOpenCommand().empty())
 665         entry->Add(wxT("open=")  + ftInfo.GetOpenCommand() + wxT(" %s "));
 666     if ( ! ftInfo.GetPrintCommand().empty())
 667         entry->Add(wxT("print=") + ftInfo.GetPrintCommand() + wxT(" %s "));
 668
 669     // now find where these extensions are in the data store and remove them
 670     wxArrayString sA_Exts = ftInfo.GetExtensions();
 671     wxString sExt, sExtStore;
 672     size_t i, nIndex;
 673     size_t nExtCount = sA_Exts.GetCount();
 674     for (i=0; i < nExtCount; i++)
 675     {
 676         sExt = sA_Exts.Item(i);
 677
 678         // clean up to just a space before and after
 679         sExt.Trim().Trim(false);
 680         sExt = wxT(' ') + sExt + wxT(' ');
 681         size_t nCount = m_aExtensions.GetCount();
 682         for (nIndex = 0; nIndex < nCount; nIndex++)
 683         {
 684             sExtStore = m_aExtensions.Item(nIndex);
 685             if (sExtStore.Replace(sExt, wxT(" ") ) > 0)
 686                 m_aExtensions.Item(nIndex) = sExtStore;
 687         }
 688     }
 689
 690     if ( !DoAssociation(strType, strIcon, entry, sA_Exts, strDesc) )
 691         return NULL;
 692
 693     return GetFileTypeFromMimeType(strType);
 694 }
 695
 696 bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType,
 697                                            const wxString& strIcon,
 698                                            wxMimeTypeCommands *entry,
 699                                            const wxArrayString& strExtensions,
 700                                            const wxString& strDesc)
 701 {
 702     int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, true);
 703
 704     if ( nIndex == wxNOT_FOUND )
 705         return false;
 706
 707     return true;
 708 }
 709
 710 int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
 711                                           const wxString& strIcon,
 712                                           wxMimeTypeCommands *entry,
 713                                           const wxArrayString& strExtensions,
 714                                           const wxString& strDesc,
 715                                           bool replaceExisting)
 716 {
 717     InitIfNeeded();
 718
 719     // ensure mimetype is always lower case
 720     wxString mimeType = strType.Lower();
 721
 722     // is this a known MIME type?
 723     int nIndex = m_aTypes.Index(mimeType);
 724     if ( nIndex == wxNOT_FOUND )
 725     {
 726         // We put MIME types containing  "application" at the end, so that
 727         // if the MIME type for the extention "htm" is searched for, it will
 728         // rather find "text/html" than "application/x-mozilla-bookmarks".
 729         if (mimeType.Find( "application" ) == 0)
 730         {
 731            // new file type
 732            m_aTypes.Add(mimeType);
 733            m_aIcons.Add(strIcon);
 734            m_aEntries.Add(entry ? entry : new wxMimeTypeCommands);
 735
 736            // change nIndex so we can use it below to add the extensions
 737            m_aExtensions.Add(wxEmptyString);
 738            nIndex = m_aExtensions.size() - 1;
 739
 740            m_aDescriptions.Add(strDesc);
 741         }
 742         else
 743         {
 744            // new file type
 745            m_aTypes.Insert(mimeType,0);
 746            m_aIcons.Insert(strIcon,0);
 747            m_aEntries.Insert(entry ? entry : new wxMimeTypeCommands,0);
 748
 749            // change nIndex so we can use it below to add the extensions
 750            m_aExtensions.Insert(wxEmptyString,0);
 751            nIndex = 0;
 752
 753            m_aDescriptions.Insert(strDesc,0);
 754         }
 755     }
 756     else // yes, we already have it
 757     {
 758         if ( replaceExisting )
 759         {
 760             // if new description change it
 761             if ( !strDesc.empty())
 762                 m_aDescriptions[nIndex] = strDesc;
 763
 764             // if new icon change it
 765             if ( !strIcon.empty())
 766                 m_aIcons[nIndex] = strIcon;
 767
 768             if ( entry )
 769             {
 770                 delete m_aEntries[nIndex];
 771                 m_aEntries[nIndex] = entry;
 772             }
 773         }
 774         else // add data we don't already have ...
 775         {
 776             // if new description add only if none
 777             if ( m_aDescriptions[nIndex].empty() )
 778                 m_aDescriptions[nIndex] = strDesc;
 779
 780             // if new icon and no existing icon
 781             if ( m_aIcons[nIndex].empty() )
 782                 m_aIcons[nIndex] = strIcon;
 783
 784             // add any new entries...
 785             if ( entry )
 786             {
 787                 wxMimeTypeCommands *entryOld = m_aEntries[nIndex];
 788
 789                 size_t count = entry->GetCount();
 790                 for ( size_t i = 0; i < count; i++ )
 791                 {
 792                     const wxString& verb = entry->GetVerb(i);
 793                     if ( !entryOld->HasVerb(verb) )
 794                     {
 795                         entryOld->AddOrReplaceVerb(verb, entry->GetCmd(i));
 796                     }
 797                 }
 798
 799                 // as we don't store it anywhere, it won't be deleted later as
 800                 // usual -- do it immediately instead
 801                 delete entry;
 802             }
 803         }
 804     }
 805
 806     // always add the extensions to this mimetype
 807     wxString& exts = m_aExtensions[nIndex];
 808
 809     // add all extensions we don't have yet
 810     wxString ext;
 811     size_t count = strExtensions.GetCount();
 812     for ( size_t i = 0; i < count; i++ )
 813     {
 814         ext = strExtensions[i];
 815         ext += wxT(' ');
 816
 817         if ( exts.Find(ext) == wxNOT_FOUND )
 818         {
 819             exts += ext;
 820         }
 821     }
 822
 823     // check data integrity
 824     wxASSERT( m_aTypes.GetCount() == m_aEntries.GetCount() &&
 825               m_aTypes.GetCount() == m_aExtensions.GetCount() &&
 826               m_aTypes.GetCount() == m_aIcons.GetCount() &&
 827               m_aTypes.GetCount() == m_aDescriptions.GetCount() );
 828
 829     return nIndex;
 830 }
 831
 832 wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
 833 {
 834     if (ext.empty() )
 835         return NULL;
 836
 837     InitIfNeeded();
 838
 839     size_t count = m_aExtensions.GetCount();
 840     for ( size_t n = 0; n < count; n++ )
 841     {
 842         wxStringTokenizer tk(m_aExtensions[n], wxT(' '));
 843
 844         while ( tk.HasMoreTokens() )
 845         {
 846             // consider extensions as not being case-sensitive
 847             if ( tk.GetNextToken().IsSameAs(ext, false /* no case */) )
 848             {
 849                 // found
 850                 wxFileType *fileType = new wxFileType;
 851                 fileType->m_impl->Init(this, n);
 852
 853                 return fileType;
 854             }
 855         }
 856     }
 857
 858     return NULL;
 859 }
 860
 861 wxFileType * wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
 862 {
 863     InitIfNeeded();
 864
 865     wxFileType * fileType = NULL;
 866     // mime types are not case-sensitive
 867     wxString mimetype(mimeType);
 868     mimetype.MakeLower();
 869
 870     // first look for an exact match
 871     int index = m_aTypes.Index(mimetype);
 872
 873     if ( index != wxNOT_FOUND )
 874     {
 875         fileType = new wxFileType;
 876         fileType->m_impl->Init(this, index);
 877     }
 878
 879     // then try to find "text/*" as match for "text/plain" (for example)
 880     // NB: if mimeType doesn't contain '/' at all, BeforeFirst() will return
 881     //     the whole string - ok.
 882
 883     index = wxNOT_FOUND;
 884     wxString strCategory = mimetype.BeforeFirst(wxT('/'));
 885
 886     size_t nCount = m_aTypes.GetCount();
 887     for ( size_t n = 0; n < nCount; n++ )
 888     {
 889         if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&
 890                 m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") )
 891         {
 892             index = n;
 893             break;
 894         }
 895     }
 896
 897     if ( index != wxNOT_FOUND )
 898     {
 899        // don't throw away fileType that was already found
 900         if (!fileType)
 901             fileType = new wxFileType;
 902         fileType->m_impl->Init(this, index);
 903     }
 904
 905     return fileType;
 906 }
 907
 908 wxString wxMimeTypesManagerImpl::GetCommand(const wxString & verb, size_t nIndex) const
 909 {
 910     wxString command, testcmd, sV, sTmp;
 911     sV = verb + wxT("=");
 912
 913     // list of verb = command pairs for this mimetype
 914     wxMimeTypeCommands * sPairs = m_aEntries [nIndex];
 915
 916     size_t i;
 917     size_t nCount = sPairs->GetCount();
 918     for ( i = 0; i < nCount; i++ )
 919     {
 920         sTmp = sPairs->GetVerbCmd (i);
 921         if ( sTmp.Contains(sV) )
 922             command = sTmp.AfterFirst(wxT('='));
 923     }
 924
 925     return command;
 926 }
 927
 928 void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
 929 {
 930     InitIfNeeded();
 931
 932     wxString extensions;
 933     const wxArrayString& exts = filetype.GetExtensions();
 934     size_t nExts = exts.GetCount();
 935     for ( size_t nExt = 0; nExt < nExts; nExt++ )
 936     {
 937         if ( nExt > 0 )
 938             extensions += wxT(' ');
 939
 940         extensions += exts[nExt];
 941     }
 942
 943     AddMimeTypeInfo(filetype.GetMimeType(),
 944                     extensions,
 945                     filetype.GetDescription());
 946 }
 947
 948 void wxMimeTypesManagerImpl::AddMimeTypeInfo(const wxString& strMimeType,
 949                                              const wxString& strExtensions,
 950                                              const wxString& strDesc)
 951 {
 952     // reading mailcap may find image/* , while
 953     // reading mime.types finds image/gif and no match is made
 954     // this means all the get functions don't work  fix this
 955     wxString strIcon;
 956     wxString sTmp = strExtensions;
 957
 958     wxArrayString sExts;
 959     sTmp.Trim().Trim(false);
 960
 961     while (!sTmp.empty())
 962     {
 963         sExts.Add(sTmp.AfterLast(wxT(' ')));
 964         sTmp = sTmp.BeforeLast(wxT(' '));
 965     }
 966
 967     AddToMimeData(strMimeType, strIcon, NULL, sExts, strDesc, true);
 968 }
 969
 970 size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
 971 {
 972     InitIfNeeded();
 973
 974     mimetypes.Empty();
 975
 976     size_t count = m_aTypes.GetCount();
 977     for ( size_t n = 0; n < count; n++ )
 978     {
 979         // don't return template types from here (i.e. anything containg '*')
 980         const wxString &type = m_aTypes[n];
 981         if ( type.Find(wxT('*')) == wxNOT_FOUND )
 982         {
 983             mimetypes.Add(type);
 984         }
 985     }
 986
 987     return mimetypes.GetCount();
 988 }
 989
 990 // ----------------------------------------------------------------------------
 991 // writing to MIME type files
 992 // ----------------------------------------------------------------------------
 993
 994 bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
 995 {
 996     InitIfNeeded();
 997
 998     wxArrayString sMimeTypes;
 999     ft->GetMimeTypes(sMimeTypes);
1000
1001     size_t i;
1002     size_t nCount = sMimeTypes.GetCount();
1003     for (i = 0; i < nCount; i ++)
1004     {
1005         const wxString &sMime = sMimeTypes.Item(i);
1006         int nIndex = m_aTypes.Index(sMime);
1007         if ( nIndex == wxNOT_FOUND)
1008         {
1009             // error if we get here ??
1010             return false;
1011         }
1012         else
1013         {
1014             m_aTypes.RemoveAt(nIndex);
1015             m_aEntries.RemoveAt(nIndex);
1016             m_aExtensions.RemoveAt(nIndex);
1017             m_aDescriptions.RemoveAt(nIndex);
1018             m_aIcons.RemoveAt(nIndex);
1019         }
1020     }
1021     // check data integrity
1022     wxASSERT( m_aTypes.GetCount() == m_aEntries.GetCount() &&
1023             m_aTypes.GetCount() == m_aExtensions.GetCount() &&
1024             m_aTypes.GetCount() == m_aIcons.GetCount() &&
1025             m_aTypes.GetCount() == m_aDescriptions.GetCount() );
1026
1027     return true;
1028 }
1029
1030 #endif
1031   // wxUSE_MIMETYPE && wxUSE_FILE