]> git.saurik.com Git - wxWidgets.git/blame - src/unix/mimetype.cpp
Updates for 2.3.1; fixed syntax error in makefile.b32 but this probably
[wxWidgets.git] / src / unix / mimetype.cpp
CommitLineData
2b813b73 1
b13d92d1 2/////////////////////////////////////////////////////////////////////////////
7dc3cc31 3// Name: unix/mimetype.cpp
b13d92d1
VZ
4// Purpose: classes and functions to manage MIME types
5// Author: Vadim Zeitlin
6// Modified by:
7// Created: 23.09.98
8// RCS-ID: $Id$
9// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
10// Licence: wxWindows license (part of wxExtra library)
11/////////////////////////////////////////////////////////////////////////////
12
2b813b73
VZ
13// known bugs; there may be others!! chris elliott, biol75@york.ac.uk 27 Mar 01
14
15// 1) .mailcap and .mimetypes can be either in a netscape or metamail format
16// and entries may get confused during writing (I've tried to fix this; please let me know
17// any files that fail)
18// 2) KDE and Gnome do not yet fully support international read/write
19// 3) Gnome key lines like open.latex."LaTeX this file"=latex %f will have odd results
20// 4) writing to files comments out the existing data; I hope this avoids losing
21// any data which we could not read, and data which we did not store like test=
22// 5) results from reading files with multiple entries (especially matches with type/* )
23// may (or may not) work for getXXX commands
24// 6) Loading the png icons in Gnome doesn't work for me...
25// 7) In Gnome, if keys.mime exists but keys.users does not, there is
26// an error message in debug mode, but the file is still written OK
27// 8) Deleting entries is only allowed from the user file; sytem wide entries
28// will be preserved during unassociate
29// 9) KDE does not yet handle multiple actions; Netscape mode n??ever will
30
f6bcfd97
BP
31// ============================================================================
32// declarations
33// ============================================================================
34
35// ----------------------------------------------------------------------------
36// headers
37// ----------------------------------------------------------------------------
38
39#ifdef __GNUG__
40 #pragma implementation "mimetype.h"
b13d92d1
VZ
41#endif
42
b13d92d1
VZ
43// for compilers that support precompilation, includes "wx.h".
44#include "wx/wxprec.h"
45
46#ifdef __BORLANDC__
ce4169a4 47 #pragma hdrstop
b13d92d1
VZ
48#endif
49
b13d92d1 50#ifndef WX_PRECOMP
ce4169a4
RR
51 #include "wx/defs.h"
52#endif
53
f6bcfd97 54#if wxUSE_FILE && wxUSE_TEXTFILE
ce4169a4
RR
55
56#ifndef WX_PRECOMP
57 #include "wx/string.h"
b12915c1
VZ
58 #if wxUSE_GUI
59 #include "wx/icon.h"
2b813b73 60
b12915c1 61 #endif
b13d92d1
VZ
62#endif //WX_PRECOMP
63
3d05544e 64
b13d92d1 65#include "wx/log.h"
ce4169a4 66#include "wx/file.h"
b13d92d1
VZ
67#include "wx/intl.h"
68#include "wx/dynarray.h"
2432b92d 69#include "wx/confbase.h"
b13d92d1 70
7dc3cc31
VS
71#include "wx/ffile.h"
72#include "wx/textfile.h"
73#include "wx/dir.h"
74#include "wx/utils.h"
75#include "wx/tokenzr.h"
b13d92d1 76
7dc3cc31 77#include "wx/unix/mimetype.h"
b13d92d1
VZ
78
79// other standard headers
80#include <ctype.h>
81
2900bd1c
JJ
82#ifdef __VMS
83/* silence warnings for comparing unsigned int's <0 */
84# pragma message disable unscomzer
85#endif
86
2b813b73
VZ
87// this is a class to extend wxArrayString...
88class wxMimeArrayString : public wxArrayString
89{
90public:
91 wxMimeArrayString ()
92 {
93 wxArrayString ();
94 }
95
96 size_t pIndexOf (const wxString & verb)
97 {
98 size_t i = 0;
99 wxString sTmp = verb;
100 // avoid a problem with modifying const parameter
101 sTmp.MakeLower();
102 while ( (i < GetCount()) && (! Item(i).MakeLower().Contains(sTmp)) )
103 {
104 i++;
105 }
106 if ( i==GetCount() ) i = (size_t)wxNOT_FOUND;
107 return i;
108 }
109
110 bool ReplaceOrAddLineCmd (const wxString verb, const wxString & cmd)
111 {
112 size_t nIndex = pIndexOf (verb);
113 if (nIndex == (size_t)wxNOT_FOUND)
114 Add(verb + wxT("=") + cmd);
115 else
116 Item(nIndex) = verb + wxT("=") + cmd;
117 return TRUE;
118 }
119
120 wxString GetVerb (size_t i)
121 {
122 if (i < 0) return wxEmptyString;
123 if (i > GetCount() ) return wxEmptyString;
124 wxString sTmp = Item(i).BeforeFirst(wxT('='));
125 return sTmp;
126 }
127
128 wxString GetCmd (size_t i)
129 {
130 if (i < 0) return wxEmptyString;
131 if (i > GetCount() ) return wxEmptyString;
132 wxString sTmp = Item(i).AfterFirst(wxT('='));
133 return sTmp;
134 }
135};
136
137//this class extends wxTextFile
138class wxMimeTextFile : public wxTextFile
139{
140public:
141 // constructors
142 wxMimeTextFile () : wxTextFile () {};
143 wxMimeTextFile (const wxString& strFile) : wxTextFile (strFile) { };
144
145 int pIndexOf(const wxString & sSearch, bool bIncludeComments = FALSE, int iStart = 0)
146 {
147 size_t i = iStart;
148 int nResult = wxNOT_FOUND;
149 if (i>=GetLineCount()) return wxNOT_FOUND;
150
151 wxString sTest = sSearch;
152 sTest.MakeLower();
153 wxString sLine;
154
155 if (bIncludeComments)
156 {
157 while ( (i < GetLineCount()) )
158 {
159 sLine = GetLine (i);
160 sLine.MakeLower();
161 if (sLine.Contains(sTest)) nResult = (int) i;
162 i++;
163 }
164 }
165 else
166 {
167 while ( (i < GetLineCount()) )
168 {
169 sLine = GetLine (i);
170 sLine.MakeLower();
171 if ( ! sLine.StartsWith(wxT("#")))
172 {
173 if (sLine.Contains(sTest)) nResult = (int) i;
174 }
175 i++;
176 }
177 }
178 return nResult;
179 }
180
181 bool CommentLine(int nIndex)
182 {
183 if (nIndex <0) return FALSE;
184 if (nIndex >= (int)GetLineCount() ) return FALSE;
185 GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
186 return TRUE;
187 }
188
189 bool CommentLine(const wxString & sTest)
190 {
191 int nIndex = pIndexOf(sTest);
192 if (nIndex <0) return FALSE;
193 if (nIndex >= (int)GetLineCount() ) return FALSE;
194 GetLine(nIndex) = GetLine(nIndex).Prepend(wxT("#"));
195 return TRUE;
196 }
197
198 wxString GetVerb (size_t i)
199 {
200 if (i < 0) return wxEmptyString;
201 if (i > GetLineCount() ) return wxEmptyString;
202 wxString sTmp = GetLine(i).BeforeFirst(wxT('='));
203 return sTmp;
204 }
205
206 wxString GetCmd (size_t i)
207 {
208 if (i < 0) return wxEmptyString;
209 if (i > GetLineCount() ) return wxEmptyString;
210 wxString sTmp = GetLine(i).AfterFirst(wxT('='));
211 return sTmp;
212 }
213};
214
b12915c1
VZ
215// in case we're compiling in non-GUI mode
216class WXDLLEXPORT wxIcon;
217
f6bcfd97
BP
218// ----------------------------------------------------------------------------
219// constants
220// ----------------------------------------------------------------------------
221
222// MIME code tracing mask
223#define TRACE_MIME _T("mime")
224
225// ----------------------------------------------------------------------------
226// private functions
227// ----------------------------------------------------------------------------
228
229// there are some fields which we don't understand but for which we don't give
230// warnings as we know that they're not important - this function is used to
231// test for them
232static bool IsKnownUnimportantField(const wxString& field);
233
b13d92d1
VZ
234// ----------------------------------------------------------------------------
235// private classes
236// ----------------------------------------------------------------------------
237
2b813b73
VZ
238
239
a6c65e88 240// This class uses both mailcap and mime.types to gather information about file
b13d92d1
VZ
241// types.
242//
a6c65e88
VZ
243// The information about mailcap file was extracted from metamail(1) sources
244// and documentation and subsequently revised when I found the RFC 1524
245// describing it.
b13d92d1
VZ
246//
247// Format of mailcap file: spaces are ignored, each line is either a comment
248// (starts with '#') or a line of the form <field1>;<field2>;...;<fieldN>.
249// A backslash can be used to quote semicolons and newlines (and, in fact,
250// anything else including itself).
251//
252// The first field is always the MIME type in the form of type/subtype (see RFC
253// 822) where subtype may be '*' meaning "any". Following metamail, we accept
254// "type" which means the same as "type/*", although I'm not sure whether this
255// is standard.
256//
257// The second field is always the command to run. It is subject to
258// parameter/filename expansion described below.
259//
260// All the following fields are optional and may not be present at all. If
261// they're present they may appear in any order, although each of them should
262// appear only once. The optional fields are the following:
263// * notes=xxx is an uninterpreted string which is silently ignored
264// * test=xxx is the command to be used to determine whether this mailcap line
265// applies to our data or not. The RHS of this field goes through the
266// parameter/filename expansion (as the 2nd field) and the resulting string
267// is executed. The line applies only if the command succeeds, i.e. returns 0
268// exit code.
269// * print=xxx is the command to be used to print (and not view) the data of
270// this type (parameter/filename expansion is done here too)
271// * edit=xxx is the command to open/edit the data of this type
a6c65e88
VZ
272// * needsterminal means that a new interactive console must be created for
273// the viewer
b13d92d1
VZ
274// * copiousoutput means that the viewer doesn't interact with the user but
275// produces (possibly) a lof of lines of output on stdout (i.e. "cat" is a
276// good example), thus it might be a good idea to use some kind of paging
277// mechanism.
278// * textualnewlines means not to perform CR/LF translation (not honored)
279// * compose and composetyped fields are used to determine the program to be
280// called to create a new message pert in the specified format (unused).
281//
a6c65e88 282// Parameter/filename expansion:
b13d92d1
VZ
283// * %s is replaced with the (full) file name
284// * %t is replaced with MIME type/subtype of the entry
285// * for multipart type only %n is replaced with the nnumber of parts and %F is
286// replaced by an array of (content-type, temporary file name) pairs for all
287// message parts (TODO)
288// * %{parameter} is replaced with the value of parameter taken from
289// Content-type header line of the message.
290//
b13d92d1
VZ
291//
292// There are 2 possible formats for mime.types file, one entry per line (used
a6c65e88
VZ
293// for global mime.types and called Mosaic format) and "expanded" format where
294// an entry takes multiple lines (used for users mime.types and called
295// Netscape format).
b13d92d1
VZ
296//
297// For both formats spaces are ignored and lines starting with a '#' are
298// comments. Each record has one of two following forms:
299// a) for "brief" format:
300// <mime type> <space separated list of extensions>
ec4768ef 301// b) for "expanded" format:
a06c1b9b
VZ
302// type=<mime type> \
303// desc="<description>" \
a6c65e88 304// exts="<comma separated list of extensions>"
b13d92d1
VZ
305//
306// We try to autodetect the format of mime.types: if a non-comment line starts
307// with "type=" we assume the second format, otherwise the first one.
308
309// there may be more than one entry for one and the same mime type, to
310// choose the right one we have to run the command specified in the test
311// field on our data.
b9517a0a
VZ
312
313// ----------------------------------------------------------------------------
2b813b73 314// wxGNOME
b9517a0a
VZ
315// ----------------------------------------------------------------------------
316
317// GNOME stores the info we're interested in in several locations:
318// 1. xxx.keys files under /usr/share/mime-info
319// 2. xxx.keys files under ~/.gnome/mime-info
320//
321// The format of xxx.keys file is the following:
322//
323// mimetype/subtype:
324// field=value
325//
326// with blank lines separating the entries and indented lines starting with
327// TABs. We're interested in the field icon-filename whose value is the path
328// containing the icon.
afaee315
VZ
329//
330// Update (Chris Elliott): apparently there may be an optional "[lang]" prefix
331// just before the field name.
b9517a0a 332
b9517a0a 333
2b813b73 334bool wxMimeTypesManagerImpl::CheckGnomeDirsExist ()
b9517a0a 335 {
2b813b73
VZ
336 wxString gnomedir;
337 wxGetHomeDir( &gnomedir );
338 wxString sTmp = gnomedir;
339 sTmp = sTmp + "/.gnome" ;
340 if (! wxDir::Exists ( sTmp ) )
b9517a0a 341 {
2b813b73 342 if (!wxMkdir ( sTmp ))
b9517a0a 343 {
2b813b73
VZ
344 wxFAIL_MSG (wxString ("Failed to create directory\n.gnome in \nCheckGnomeDirsExist") + sTmp );
345 return FALSE;
b9517a0a
VZ
346 }
347 }
2b813b73
VZ
348 sTmp = sTmp + "/mime-info";
349 if (! wxDir::Exists ( sTmp ) )
b9517a0a 350 {
2b813b73
VZ
351 if (!wxMkdir ( sTmp ))
352 {
353 wxFAIL_MSG (wxString ("Failed to create directory\nmime-info in \nCheckGnomeDirsExist") + sTmp );
354 return FALSE;
b9517a0a 355 }
2b813b73
VZ
356 }
357 return TRUE;
b9517a0a 358
2b813b73
VZ
359}
360
361
362
363bool wxMimeTypesManagerImpl::WriteGnomeKeyFile(int index, bool delete_index)
364 {
365 wxString gnomedir;
366 wxGetHomeDir( &gnomedir );
367
368 wxMimeTextFile outfile ( gnomedir + "/.gnome/mime-info/user.keys");
369 // if this fails probably Gnome is not installed ??
370 // create it anyway as a private mime store
371
372 if (! outfile.Open () )
373 {
374 if (delete_index) return FALSE;
375 if (!CheckGnomeDirsExist() ) return FALSE;
376 outfile.Create ();
377 }
378
379 wxString sTmp, strType = m_aTypes[index];
380 int nIndex = outfile.pIndexOf(strType);
381 if ( nIndex == wxNOT_FOUND )
b9517a0a 382 {
2b813b73
VZ
383 outfile.AddLine ( strType + wxT(':') );
384 // see file:/usr/doc/gnome-libs-devel-1.0.40/devel-docs/mime-type-handling.txt
385 // as this does not deal with internationalisation
386 // wxT( "\t[en_US]") + verb + wxT ('=') + cmd + wxT(" %f");
387 wxMimeArrayString * entries = m_aEntries[index];
388 size_t i;
389 for (i=0; i < entries->GetCount(); i++)
b9517a0a 390 {
2b813b73
VZ
391 sTmp = entries->Item(i);
392 sTmp.Replace( wxT("%s"), wxT("%f") );
393 sTmp = wxT ( "\t") + sTmp;
394 outfile.AddLine ( sTmp );
395 }
396 //for international use do something like this
397 //outfile.AddLine ( wxString( "\t[en_US]icon-filename=") + cmd );
398 outfile.AddLine ( wxT( "\ticon-filename=") + m_aIcons[index] );
b9517a0a
VZ
399 }
400 else
401 {
2b813b73
VZ
402 if (delete_index) outfile.CommentLine(nIndex);
403 wxMimeArrayString sOld;
404 size_t nOld = nIndex + 1;
405 bool oldEntryEnd = FALSE;
406 while ( (nOld < outfile.GetLineCount() )&& (oldEntryEnd == FALSE ))
407 {
408 sTmp = outfile.GetLine(nOld);
409 if ( (sTmp[0u] == wxT('\t')) || (sTmp[0u] == wxT('#')) )
410 {
411 // we have another line to deal with
412 outfile.CommentLine(nOld);
413 nOld ++;
414 // add the line to our store
415 if ((!delete_index) && (sTmp[0u] == wxT('\t'))) sOld.Add(sTmp);
b9517a0a 416 }
2b813b73
VZ
417 // next mimetpye ??or blank line
418 else oldEntryEnd = TRUE;
b9517a0a 419 }
2b813b73
VZ
420 // list of entries in our data; these should all be in sOld,
421 // though sOld may also contain other entries , eg flags
422 if (!delete_index)
b9517a0a 423 {
2b813b73
VZ
424 wxMimeArrayString * entries = m_aEntries[index];
425 size_t i;
426 for (i=0; i < entries->GetCount(); i++)
427 {
428 // replace any entries in sold that match verbs we know
429 sOld.ReplaceOrAddLineCmd ( entries->GetVerb(i), entries->GetCmd (i) );
b9517a0a 430 }
2b813b73
VZ
431 //sOld should also contain the icon
432 if ( !m_aIcons[index].IsEmpty() )
433 sOld.ReplaceOrAddLineCmd ( wxT( "icon-filename"), m_aIcons[index] );
b9517a0a 434
2b813b73
VZ
435 for (i=0; i < sOld.GetCount(); i++)
436 {
437 sTmp = sOld.Item(i);
438 sTmp.Replace( wxT("%s"), wxT("%f") );
439 sTmp = wxT ( "\t") + sTmp;
440 nIndex ++;
441 outfile.InsertLine ( sTmp, nIndex );
442 }
443 }
444 }
445 bool bTmp = outfile.Write ();
446 return bTmp;
b9517a0a
VZ
447 }
448
b9517a0a 449
2b813b73 450bool wxMimeTypesManagerImpl::WriteGnomeMimeFile(int index, bool delete_index)
afaee315 451 {
2b813b73
VZ
452 wxString gnomedir;
453 wxGetHomeDir( &gnomedir );
afaee315 454
2b813b73
VZ
455 wxMimeTextFile outfile ( gnomedir + "/.gnome/mime-info/user.mime");
456 // if this fails probably Gnome is not installed ??
457 // create it anyway as a private mime store
458 if (! outfile.Open () )
459 {
460 if (delete_index) return FALSE;
461 if (!CheckGnomeDirsExist() ) return FALSE;
462 outfile.Create ();
463 }
464 wxString strType = m_aTypes[index];
465 int nIndex = outfile.pIndexOf(strType);
466 if ( nIndex == wxNOT_FOUND )
b9517a0a 467 {
2b813b73
VZ
468 outfile.AddLine ( strType );
469 outfile.AddLine ( wxT( "\text:") + m_aExtensions.Item(index) );
b9517a0a 470 }
2b813b73
VZ
471 else
472 {
473 if (delete_index)
474 {
475 outfile.CommentLine(nIndex);
476 outfile.CommentLine(nIndex+1);
b9517a0a
VZ
477 }
478 else
2b813b73
VZ
479 {// check for next line being the right one to replace ??
480 wxString sOld = outfile.GetLine(nIndex+1);
481 if (sOld.Contains(wxT("\text: ")))
b9517a0a 482 {
2b813b73
VZ
483 outfile.GetLine(nIndex+1) = wxT( "\text: ") + m_aExtensions.Item(index);
484 }
485 else
b9517a0a 486 {
2b813b73 487 outfile.InsertLine(wxT( "\text: ") + m_aExtensions.Item(index), nIndex + 1 );
b9517a0a 488 }
4d2976ad
VS
489 }
490 }
2b813b73
VZ
491 bool bTmp = outfile.Write ();
492 return bTmp;
4d2976ad
VS
493}
494
2b813b73
VZ
495
496void wxMimeTypesManagerImpl::LoadGnomeDataFromKeyFile(const wxString& filename)
4d2976ad 497{
2b813b73
VZ
498 wxTextFile textfile(filename);
499 if ( !textfile.Open() )
500 return;
501 wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s ---"),
502 filename.c_str());
4d2976ad 503
2b813b73
VZ
504 // values for the entry being parsed
505 wxString curMimeType, curIconFile;
506 wxMimeArrayString * entry = new wxMimeArrayString;
4d2976ad 507
2b813b73
VZ
508 // these are always empty in this file
509 wxArrayString strExtensions;
510 wxString strDesc;
4d2976ad 511
2b813b73
VZ
512 const wxChar *pc;
513 size_t nLineCount = textfile.GetLineCount();
514 size_t nLine = 0;
515 while ( nLine < nLineCount)
516 {
517 pc = textfile[nLine].c_str();
518 if ( *pc != _T('#') )
519 {
4d2976ad 520
2b813b73
VZ
521 wxLogTrace(TRACE_MIME, wxT("--- Reading from Gnome file %s '%s' ---"),
522 filename.c_str(),pc);
4d2976ad 523
2b813b73
VZ
524 wxString sTmp(pc);
525 if (sTmp.Contains(wxT("=")) )
526 {
527 if (sTmp.Contains( wxT("icon-filename=") ) )
528 {
529 curIconFile = sTmp.AfterFirst(wxT('='));
530 }
531 else //: some other field,
4d2976ad 532 {
2b813b73
VZ
533 //may contain lines like this (RH7)
534 // \t[lang]open.tex."TeX this file"=tex %f
535 // \tflags.tex.flags=needsterminal
536 // \topen.latex."LaTeX this file"=latex %f
537 // \tflags.latex.flags=needsterminal
538
539 // \topen=xdvi %f
540 // \tview=xdvi %f
541 // \topen.convert.Convert file to Postscript=dvips %f -o `basename %f .dvi`.ps
542
543 // for now ignore lines with flags in...FIX
544 sTmp = sTmp.AfterLast(wxT(']'));
545 sTmp = sTmp.AfterLast(wxT('\t'));
546 sTmp.Trim(FALSE).Trim();
547 if (0 == sTmp.Replace ( wxT("%f"), wxT("%s") )) sTmp = sTmp + wxT(" %s");
548 entry->Add(sTmp);
4d2976ad 549
2b813b73
VZ
550 }
551
552 } // emd of has an equals sign
553 else
554 {
555 // not a comment and not an equals sign
556 if (sTmp.Contains(wxT('/')))
557 {
558 // this is the start of the new mimetype
559 // overwrite any existing data
560 if (! curMimeType.IsEmpty())
561 {
562 AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
563
564 // now get ready for next bit
565 entry = new wxMimeArrayString;
566 }
567 curMimeType = sTmp.BeforeFirst(wxT(':'));
568 }
4d2976ad 569 }
2b813b73
VZ
570 } // end of not a comment
571 // ignore blank lines
572 nLine ++;
573 } // end of while, save any data
574 if (! curMimeType.IsEmpty())
575 {
576 AddToMimeData ( curMimeType, curIconFile, entry, strExtensions, strDesc);
577 }
578
4d2976ad
VS
579}
580
581
2b813b73
VZ
582
583void wxMimeTypesManagerImpl::LoadGnomeMimeTypesFromMimeFile(const wxString& filename)
4d2976ad
VS
584{
585 wxTextFile textfile(filename);
586 if ( !textfile.Open() )
587 return;
2b813b73
VZ
588 wxLogTrace(TRACE_MIME, wxT("--- Opened Gnome file %s ---"),
589 filename.c_str());
4d2976ad
VS
590
591 // values for the entry being parsed
592 wxString curMimeType, curExtList;
593
594 const wxChar *pc;
595 size_t nLineCount = textfile.GetLineCount();
596 for ( size_t nLine = 0; ; nLine++ )
597 {
598 if ( nLine < nLineCount )
599 {
600 pc = textfile[nLine].c_str();
601 if ( *pc == _T('#') )
602 {
603 // skip comments
604 continue;
605 }
606 }
607 else
608 {
609 // so that we will fall into the "if" below
610 pc = NULL;
611 }
b9517a0a 612
4d2976ad
VS
613 if ( !pc || !*pc )
614 {
615 // end of the entry
616 if ( !!curMimeType && !!curExtList )
b9517a0a 617 {
2b813b73
VZ
618 wxLogTrace(TRACE_MIME, wxT("--- At end of Gnome file finding mimetype %s ---"),
619 curMimeType.c_str());
620
621 AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
4d2976ad 622 }
b9517a0a 623
4d2976ad
VS
624 if ( !pc )
625 {
626 // the end - this can only happen if nLine == nLineCount
b9517a0a
VZ
627 break;
628 }
4d2976ad
VS
629
630 curExtList.Empty();
631
632 continue;
633 }
634
635 // what do we have here?
636 if ( *pc == _T('\t') )
637 {
638 // this is a field=value ling
639 pc++; // skip leading TAB
640
641 static const int lenField = 4; // strlen("ext:")
642 if ( wxStrncmp(pc, _T("ext:"), lenField) == 0 )
643 {
644 // skip ' ' which follows and take everything left until the end
645 // of line
646 curExtList = pc + lenField + 1;
647 }
648 //else: some other field, we don't care
649 }
650 else
651 {
652 // this is the start of the new section
2b813b73
VZ
653 wxLogTrace(TRACE_MIME, wxT("--- In Gnome file finding mimetype %s ---"),
654 curMimeType.c_str());
655
656 if (! curMimeType.IsEmpty()) AddMimeTypeInfo(curMimeType, curExtList, wxEmptyString);
657
4d2976ad
VS
658 curMimeType.Empty();
659
660 while ( *pc != _T(':') && *pc != _T('\0') )
661 {
662 curMimeType += *pc++;
663 }
b9517a0a
VZ
664 }
665 }
666}
667
4d2976ad 668
2b813b73 669void wxMimeTypesManagerImpl::LoadGnomeMimeFilesFromDir(const wxString& dirbase)
b9517a0a
VZ
670{
671 wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
672 _T("base directory shouldn't end with a slash") );
673
674 wxString dirname = dirbase;
675 dirname << _T("/mime-info");
676
677 if ( !wxDir::Exists(dirname) )
678 return;
679
680 wxDir dir(dirname);
681 if ( !dir.IsOpened() )
682 return;
683
684 // we will concatenate it with filename to get the full path below
685 dirname += _T('/');
686
687 wxString filename;
4d2976ad 688 bool cont = dir.GetFirst(&filename, _T("*.mime"), wxDIR_FILES);
b9517a0a
VZ
689 while ( cont )
690 {
2b813b73 691 LoadGnomeMimeTypesFromMimeFile(dirname + filename);
b9517a0a
VZ
692
693 cont = dir.GetNext(&filename);
694 }
fb5ddb4c 695
2b813b73
VZ
696 cont = dir.GetFirst(&filename, _T("*.keys"), wxDIR_FILES);
697 while ( cont )
b9517a0a 698 {
2b813b73 699 LoadGnomeDataFromKeyFile(dirname + filename);
b9517a0a 700
2b813b73
VZ
701 cont = dir.GetNext(&filename);
702 }
b9517a0a
VZ
703}
704
4d2976ad 705
2b813b73
VZ
706
707
708void wxMimeTypesManagerImpl::GetGnomeMimeInfo(const wxString& sExtraDir)
4d2976ad 709{
2b813b73 710
4d2976ad
VS
711 wxArrayString dirs;
712 dirs.Add(_T("/usr/share"));
713 dirs.Add(_T("/usr/local/share"));
714
715 wxString gnomedir;
716 wxGetHomeDir( &gnomedir );
717 gnomedir += _T("/.gnome");
718 dirs.Add( gnomedir );
2b813b73 719 if (!sExtraDir.IsEmpty()) dirs.Add( sExtraDir );
4d2976ad
VS
720
721 size_t nDirs = dirs.GetCount();
722 for ( size_t nDir = 0; nDir < nDirs; nDir++ )
723 {
2b813b73 724 LoadGnomeMimeFilesFromDir(dirs[nDir]);
4d2976ad
VS
725 }
726}
727
728
b9517a0a 729
b9517a0a 730
2b813b73 731// end of gnome
b9517a0a
VZ
732
733// ----------------------------------------------------------------------------
2b813b73 734// wxKDE
b9517a0a
VZ
735// ----------------------------------------------------------------------------
736
737// KDE stores the icon info in its .kdelnk files. The file for mimetype/subtype
738// may be found in either of the following locations
739//
509a6196 740// 1. $KDEDIR/share/mimelnk/mimetype/subtype.kdelnk
b9517a0a
VZ
741// 2. ~/.kde/share/mimelnk/mimetype/subtype.kdelnk
742//
743// The format of a .kdelnk file is almost the same as the one used by
744// wxFileConfig, i.e. there are groups, comments and entries. The icon is the
745// value for the entry "Type"
746
2b813b73
VZ
747// kde writing; see http://webcvs.kde.org/cgi-bin/cvsweb.cgi/~checkout~/kdelibs/kio/DESKTOP_ENTRY_STANDARD
748// for now write to .kdelnk but should eventually do .desktop instead (in preference??)
749
750bool wxMimeTypesManagerImpl::CheckKDEDirsExist ( const wxString & sOK, const wxString & sTest )
751
752 {
753 if (sTest.IsEmpty())
754 {
755 if (wxDir::Exists(sOK)) return TRUE;
756 else return FALSE;
757 }
758 else
759 {
760 wxString sStart = sOK + wxT("/") + sTest.BeforeFirst(wxT('/'));
761 if (!wxDir::Exists(sStart)) wxMkdir(sStart);
762 wxString sEnd = sTest.AfterFirst(wxT('/'));
763 return CheckKDEDirsExist(sStart, sEnd);
764 }
765}
766
767bool wxMimeTypesManagerImpl::WriteKDEMimeFile(int index, bool delete_index)
768{
769 wxMimeTextFile appoutfile, mimeoutfile;
770 wxString sHome = wxGetHomeDir();
771 wxString sTmp = wxT(".kde/share/mimelnk/");
772 wxString sMime = m_aTypes[index] ;
773 CheckKDEDirsExist (sHome, sTmp + sMime.BeforeFirst(wxT('/')) );
774 sTmp = sHome + wxT('/') + sTmp + sMime + wxT(".kdelnk");
775
776 bool bTemp;
777 bool bMimeExists = mimeoutfile.Open (sTmp);
778 if (!bMimeExists)
779 {
780 bTemp = mimeoutfile.Create (sTmp);
781 // some unknown error eg out of disk space
782 if (!bTemp) return FALSE;
783 }
784
785 sTmp = wxT(".kde/share/applnk/");
786 CheckKDEDirsExist (sHome, sTmp + sMime.AfterFirst(wxT('/')) );
787 sTmp = sHome + wxT('/') + sTmp + sMime.AfterFirst(wxT('/')) + wxT(".kdelnk");
788
789 bool bAppExists;
790 bAppExists = appoutfile.Open (sTmp);
791 if (!bAppExists)
792 {
793 bTemp = appoutfile.Create (sTmp);
794 // some unknown error eg out of disk space
795 if (!bTemp) return FALSE;
796 }
797
798 // fixed data; write if new file
799 if (!bMimeExists)
800 {
801 mimeoutfile.AddLine(wxT("#KDE Config File"));
802 mimeoutfile.AddLine(wxT("[KDE Desktop Entry]"));
803 mimeoutfile.AddLine(wxT("Version=1.0"));
804 mimeoutfile.AddLine(wxT("Type=MimeType"));
805 mimeoutfile.AddLine(wxT("MimeType=") + sMime);
806 }
807
808 if (!bAppExists)
809 {
810 mimeoutfile.AddLine(wxT("#KDE Config File"));
811 mimeoutfile.AddLine(wxT("[KDE Desktop Entry]"));
812 appoutfile.AddLine(wxT("Version=1.0"));
813 appoutfile.AddLine(wxT("Type=Application"));
814 appoutfile.AddLine(wxT("MimeType=") + sMime + wxT(';'));
815 }
816
817 // variable data
818 // ignore locale
819 mimeoutfile.CommentLine(wxT("Comment="));
820 if (!delete_index)
821 mimeoutfile.AddLine(wxT("Comment=") + m_aDescriptions[index]);
822 appoutfile.CommentLine(wxT("Name="));
823 if (!delete_index)
824 appoutfile.AddLine(wxT("Comment=") + m_aDescriptions[index]);
825
826 sTmp = m_aIcons[index];
827 // we can either give the full path, or the shortfilename if its in
828 // one of the directories we search
829 mimeoutfile.CommentLine(wxT("Icon=") );
830 if (!delete_index) mimeoutfile.AddLine(wxT("Icon=") + sTmp );
831 appoutfile.CommentLine(wxT("Icon=") );
832 if (!delete_index) appoutfile.AddLine(wxT("Icon=") + sTmp );
833
834 sTmp = wxT(" ") + m_aExtensions[index];
835
836 wxStringTokenizer tokenizer(sTmp, _T(" "));
837 sTmp = wxT("Patterns=");
838 mimeoutfile.CommentLine(sTmp);
839 while ( tokenizer.HasMoreTokens() )
840 {
841 // holds an extension; need to change it to *.ext;
842 wxString e = wxT("*.") + tokenizer.GetNextToken() + wxT(";");
843 sTmp = sTmp + e;
844}
845 if (!delete_index) mimeoutfile.AddLine(sTmp);
846
847 wxMimeArrayString * entries = m_aEntries[index];
848 // if we don't find open just have an empty string ... FIX this
849 size_t iOpen = entries->pIndexOf(wxT("open"));
850 sTmp = entries->GetCmd(iOpen);
851 sTmp.Replace( wxT("%s"), wxT("%f") );
852
853 mimeoutfile.CommentLine(wxT("DefaultApp=") );
854 if (!delete_index) mimeoutfile.AddLine(wxT("DefaultApp=") + sTmp);
855
856 sTmp.Replace( wxT("%f"), wxT("") );
857 appoutfile.CommentLine(wxT("Exec="));
858 if (!delete_index) appoutfile.AddLine(wxT("Exec=") + sTmp);
859
860 if (entries->GetCount() > 1)
861 {
862 //other actions as well as open
863
864 }
865 bTemp = FALSE;
866 if (mimeoutfile.Write ()) bTemp = TRUE;
867 mimeoutfile.Close ();
868 if (appoutfile.Write ()) bTemp = TRUE;
869 appoutfile.Close ();
870
871 return bTemp;
872
873
874}
875
876void wxMimeTypesManagerImpl::LoadKDELinksForMimeSubtype(const wxString& dirbase,
b9517a0a 877 const wxString& subdir,
cdf339c9
VS
878 const wxString& filename,
879 const wxArrayString& icondirs)
b9517a0a 880{
2b813b73
VZ
881 wxMimeTextFile file;
882 if ( !file.Open(dirbase + filename) ) return;
b9517a0a 883
2b813b73
VZ
884 wxMimeArrayString * entry = new wxMimeArrayString;
885 wxArrayString sExts;
886 wxString mimetype, mime_desc, strIcon;
887
888 int nIndex = file.pIndexOf ("MimeType=");
889 if (nIndex == wxNOT_FOUND)
890 {
cdf339c9
VS
891 // construct mimetype from the directory name and the basename of the
892 // file (it always has .kdelnk extension)
cdf339c9 893 mimetype << subdir << _T('/') << filename.BeforeLast(_T('.'));
2b813b73
VZ
894 }
895 else mimetype = file.GetCmd (nIndex);
b9517a0a 896
276c7463
VZ
897 // first find the description string: it is the value in either "Comment="
898 // line or "Comment[<locale_name>]=" one
2b813b73 899 nIndex = wxNOT_FOUND;
276c7463
VZ
900
901 wxString comment;
902#if wxUSE_INTL
903 wxLocale *locale = wxGetLocale();
904 if ( locale )
905 {
906 // try "Comment[locale name]" first
907 comment << _T("Comment[") + locale->GetName() + _T("]=");
2b813b73 908 nIndex = file.pIndexOf(comment);
276c7463
VZ
909 }
910#endif // wxUSE_INTL
cdf339c9 911
2b813b73 912 if ( nIndex == wxNOT_FOUND )
276c7463
VZ
913 {
914 comment = _T("Comment=");
2b813b73 915 nIndex = file.pIndexOf(comment);
276c7463
VZ
916 }
917
2b813b73 918 if ( nIndex != wxNOT_FOUND ) mime_desc = file.GetCmd(nIndex);
276c7463 919 //else: no description
cdf339c9 920
276c7463
VZ
921 // next find the extensions
922 wxString mime_extension;
923
2b813b73
VZ
924 nIndex = file.pIndexOf(_T("Patterns="));
925 if ( nIndex != wxNOT_FOUND )
276c7463 926 {
2b813b73 927 wxString exts = file.GetCmd (nIndex) ;;
5bd3a2da 928
276c7463
VZ
929 wxStringTokenizer tokenizer(exts, _T(";"));
930 while ( tokenizer.HasMoreTokens() )
cdf339c9 931 {
276c7463
VZ
932 wxString e = tokenizer.GetNextToken();
933 if ( e.Left(2) != _T("*.") )
934 continue; // don't support too difficult patterns
935
936 if ( !mime_extension.empty() )
937 {
938 // separate from the previous ext
939 mime_extension << _T(' ');
940 }
941
cdf339c9 942 mime_extension << e.Mid(2);
cdf339c9 943 }
cdf339c9 944 }
2b813b73 945 sExts.Add(mime_extension);
5bd3a2da 946
cdf339c9
VS
947
948 // ok, now we can take care of icon:
949
2b813b73
VZ
950 nIndex = file.pIndexOf(_T("Icon="));
951 if ( nIndex != wxNOT_FOUND )
b9517a0a 952 {
2b813b73
VZ
953 strIcon = file.GetCmd(nIndex);
954 //it could be the real path, but more often a short name
955 if (!wxFileExists(strIcon))
b9517a0a 956 {
2b813b73
VZ
957 // icon is just the short name
958 if ( !strIcon.IsEmpty() )
b9517a0a 959 {
cdf339c9
VS
960 // we must check if the file exists because it may be stored
961 // in many locations, at least ~/.kde and $KDEDIR
962 size_t nDir, nDirs = icondirs.GetCount();
963 for ( nDir = 0; nDir < nDirs; nDir++ )
2b813b73 964 if (wxFileExists(icondirs[nDir] + strIcon))
cdf339c9 965 {
2b813b73 966 strIcon.Prepend(icondirs[nDir]);
cdf339c9
VS
967 break;
968 }
2b813b73
VZ
969 }
970 }
971 }
972 // now look for lines which know about the application
973 // exec= or DefaultApp=
974
975 nIndex = file.pIndexOf(wxT("DefaultApp"));
b9517a0a 976
2b813b73 977 if ( nIndex == wxNOT_FOUND )
b9517a0a 978 {
2b813b73
VZ
979 // no entry try exec
980 nIndex = file.pIndexOf(wxT("Exec"));
b9517a0a 981 }
2b813b73
VZ
982
983 if ( nIndex != wxNOT_FOUND )
b9517a0a 984 {
2b813b73
VZ
985 wxString sTmp = file.GetCmd(nIndex);
986 // we expect %f; others including %F and %U and %u are possible
987 if (0 == sTmp.Replace ( wxT("%f"), wxT("%s") )) sTmp = sTmp + wxT(" %s");
988 entry->ReplaceOrAddLineCmd (wxString(wxT("open")), sTmp );
b9517a0a 989 }
2b813b73
VZ
990
991 AddToMimeData (mimetype, strIcon, entry, sExts, mime_desc);
992
993
b9517a0a
VZ
994}
995
2b813b73 996void wxMimeTypesManagerImpl::LoadKDELinksForMimeType(const wxString& dirbase,
cdf339c9
VS
997 const wxString& subdir,
998 const wxArrayString& icondirs)
b9517a0a
VZ
999{
1000 wxString dirname = dirbase;
1001 dirname += subdir;
1002 wxDir dir(dirname);
1003 if ( !dir.IsOpened() )
1004 return;
1005
1006 dirname += _T('/');
1007
1008 wxString filename;
1009 bool cont = dir.GetFirst(&filename, _T("*.kdelnk"), wxDIR_FILES);
1010 while ( cont )
1011 {
2b813b73
VZ
1012 LoadKDELinksForMimeSubtype(dirname, subdir, filename, icondirs);
1013
1014 cont = dir.GetNext(&filename);
1015 }
1016 // new standard for Gnome and KDE
1017 cont = dir.GetFirst(&filename, _T("*.desktop"), wxDIR_FILES);
1018 while ( cont )
1019 {
1020 LoadKDELinksForMimeSubtype(dirname, subdir, filename, icondirs);
b9517a0a
VZ
1021
1022 cont = dir.GetNext(&filename);
1023 }
1024}
1025
2b813b73 1026void wxMimeTypesManagerImpl::LoadKDELinkFilesFromDir(const wxString& dirbase,
cdf339c9 1027 const wxArrayString& icondirs)
b9517a0a
VZ
1028{
1029 wxASSERT_MSG( !!dirbase && !wxEndsWithPathSeparator(dirbase),
1030 _T("base directory shouldn't end with a slash") );
1031
1032 wxString dirname = dirbase;
1033 dirname << _T("/mimelnk");
1034
1035 if ( !wxDir::Exists(dirname) )
1036 return;
1037
1038 wxDir dir(dirname);
1039 if ( !dir.IsOpened() )
1040 return;
1041
1042 // we will concatenate it with dir name to get the full path below
1043 dirname += _T('/');
1044
1045 wxString subdir;
1046 bool cont = dir.GetFirst(&subdir, wxEmptyString, wxDIR_DIRS);
1047 while ( cont )
1048 {
2b813b73 1049 LoadKDELinksForMimeType(dirname, subdir, icondirs);
b9517a0a
VZ
1050
1051 cont = dir.GetNext(&subdir);
1052 }
1053}
1054
2b813b73 1055void wxMimeTypesManagerImpl::GetKDEMimeInfo(const wxString& sExtraDir)
b9517a0a
VZ
1056{
1057 wxArrayString dirs;
cdf339c9
VS
1058 wxArrayString icondirs;
1059
1060 // settings in ~/.kde have maximal priority
1061 dirs.Add(wxGetHomeDir() + _T("/.kde/share"));
1062 icondirs.Add(wxGetHomeDir() + _T("/.kde/share/icons/"));
509a6196
VZ
1063
1064 // the variable KDEDIR is set when KDE is running
1065 const char *kdedir = getenv("KDEDIR");
1066 if ( kdedir )
1067 {
1068 dirs.Add(wxString(kdedir) + _T("/share"));
cdf339c9 1069 icondirs.Add(wxString(kdedir) + _T("/share/icons/"));
509a6196
VZ
1070 }
1071 else
1072 {
1073 // try to guess KDEDIR
1074 dirs.Add(_T("/usr/share"));
1075 dirs.Add(_T("/opt/kde/share"));
cdf339c9 1076 icondirs.Add(_T("/usr/share/icons/"));
13e3b45a 1077 icondirs.Add(_T("/usr/X11R6/share/icons/")); // Debian/Corel linux
cdf339c9 1078 icondirs.Add(_T("/opt/kde/share/icons/"));
509a6196
VZ
1079 }
1080
2b813b73
VZ
1081 if (!sExtraDir.IsEmpty()) dirs.Add (sExtraDir);
1082 icondirs.Add(sExtraDir + wxT("/icons"));
1083
b9517a0a
VZ
1084 size_t nDirs = dirs.GetCount();
1085 for ( size_t nDir = 0; nDir < nDirs; nDir++ )
1086 {
2b813b73 1087 LoadKDELinkFilesFromDir(dirs[nDir], icondirs);
b9517a0a
VZ
1088 }
1089
2b813b73 1090
b9517a0a
VZ
1091}
1092
2b813b73
VZ
1093// end of KDE
1094
1095// ----------------------------------------------------------------------------
1096// wxFileTypeImpl (Unix)
1097// ----------------------------------------------------------------------------
1098
1099
1100wxString wxFileTypeImpl::GetExpandedCommand(const wxString & verb, const wxFileType::MessageParameters& params) const
b9517a0a 1101{
2b813b73
VZ
1102 wxString sTmp;
1103 size_t i = 0;
1104 while ( (i < m_index.GetCount() ) && sTmp.IsEmpty() )
b9517a0a 1105 {
2b813b73
VZ
1106 sTmp = m_manager->GetCommand ( verb, m_index[i] );
1107 i ++;
b9517a0a
VZ
1108 }
1109
2b813b73
VZ
1110 return wxFileType::ExpandCommand(sTmp, params);
1111}
b9517a0a 1112
c786f763
VZ
1113bool wxFileTypeImpl::GetIcon(wxIcon *icon,
1114 wxString *iconFile /*= NULL */,
1115 int *iconIndex /*= NULL*/) const
2b813b73
VZ
1116
1117{
c786f763 1118#if wxUSE_GUI
2b813b73
VZ
1119 wxString sTmp;
1120 size_t i = 0;
1121 while ( (i < m_index.GetCount() ) && sTmp.IsEmpty() )
c786f763
VZ
1122 {
1123 sTmp = m_manager->m_aIcons[m_index[i]];
1124 i ++;
1125 }
2b813b73 1126 if ( sTmp.IsEmpty () ) return FALSE;
b9517a0a 1127
be0a33fb 1128 wxIcon icn;
2b813b73
VZ
1129
1130 if (sTmp.Right(4).MakeUpper() == _T(".XPM"))
1131 icn = wxIcon(sTmp);
1132 else
1133 icn = wxIcon(sTmp, wxBITMAP_TYPE_ANY);
1134
1135 if ( icn.Ok() )
c786f763
VZ
1136 {
1137 *icon = icn;
1138 if (iconFile) *iconFile = sTmp;
1139 if (iconIndex) *iconIndex = 0;
1140 return TRUE;
2b813b73 1141 }
c786f763
VZ
1142#endif // wxUSE_GUI
1143
1144 return FALSE;
1145}
2b813b73
VZ
1146
1147
1148bool
1149wxFileTypeImpl::GetMimeTypes(wxArrayString& mimeTypes) const
1150{
1151 mimeTypes.Clear();
1152 for (size_t i = 0; i < m_index.GetCount(); i++)
1153 mimeTypes.Add(m_manager->m_aTypes[m_index[i]]);
1154 return TRUE;
1155}
1156
1157
1158size_t wxFileTypeImpl::GetAllCommands(wxArrayString *verbs,
1159 wxArrayString *commands,
1160 const wxFileType::MessageParameters& params) const
1161{
1162
1163 wxString vrb, cmd, sTmp;
1164 size_t count = 0;
1165 wxMimeArrayString * sPairs;
1166
1167 // verbs and commands have been cleared already in mimecmn.cpp...
1168 // if we find no entries in the exact match, try the inexact match
1169 for (size_t n = 0; ((count ==0) && (n < m_index.GetCount())); n++)
1170 {
1171 // list of verb = command pairs for this mimetype
1172 sPairs = m_manager->m_aEntries [m_index[n]];
1173 size_t i;
1174 for ( i = 0; i < sPairs->GetCount () ; i++ )
1175 {
1176 vrb = sPairs->GetVerb(i);
1177 // some gnome entries have . inside
1178 vrb = vrb.AfterLast(wxT('.'));
1179 cmd = sPairs->GetCmd (i);
1180 if (! cmd.IsEmpty() )
1181 {
1182 cmd = wxFileType::ExpandCommand(cmd, params);
1183 count ++;
1184 if ( vrb.IsSameAs (wxT("open")))
1185 {
1186 verbs->Insert(vrb,0u);
1187 commands ->Insert(cmd,0u);
1188 }
1189 else
1190 {
1191 verbs->Add (vrb);
1192 commands->Add (cmd);
1193 }
1194 }
1195
1196 }
1197
1198 }
1199 return count;
1200
1201}
1202
1203bool wxFileTypeImpl::GetExtensions(wxArrayString& extensions)
1204{
1205 wxString strExtensions = m_manager->GetExtension(m_index[0]);
1206 extensions.Empty();
1207
1208 // one extension in the space or comma delimitid list
1209 wxString strExt;
1210 for ( const wxChar *p = strExtensions; ; p++ ) {
1211 if ( *p == wxT(' ') || *p == wxT(',') || *p == wxT('\0') ) {
1212 if ( !strExt.IsEmpty() ) {
1213 extensions.Add(strExt);
1214 strExt.Empty();
1215 }
1216 //else: repeated spaces (shouldn't happen, but it's not that
1217 // important if it does happen)
1218
1219 if ( *p == wxT('\0') )
1220 break;
1221 }
1222 else if ( *p == wxT('.') ) {
1223 // remove the dot from extension (but only if it's the first char)
1224 if ( !strExt.IsEmpty() ) {
1225 strExt += wxT('.');
1226 }
1227 //else: no, don't append it
1228 }
1229 else {
1230 strExt += *p;
1231 }
1232 }
1233
1234 return TRUE;
1235}
1236
1237// set an arbitrary command,
1238// could adjust the code to ask confirmation if it already exists and
1239// overwriteprompt is TRUE, but this is currently ignored as *Associate* has
1240// no overwrite prompt
1241bool wxFileTypeImpl::SetCommand(const wxString& cmd, const wxString& verb, bool overwriteprompt /*= TRUE*/)
1242 {
1243 wxArrayString strExtensions;
1244 wxString strDesc, strIcon ;
1245
1246 wxMimeArrayString *entry = new wxMimeArrayString ();
1247 entry->Add(verb + wxT("=") + cmd + wxT(" %s "));
1248
1249 wxArrayString strTypes;
1250 GetMimeTypes (strTypes);
1251 if (strTypes.GetCount() < 1) return FALSE;
1252
1253 size_t i;
1254 bool Ok = TRUE;
1255 for (i = 0; i < strTypes.GetCount(); i++)
1256 {
1257 if (!m_manager->DoAssociation (strTypes[i], strIcon, entry, strExtensions, strDesc))
1258 Ok = FALSE;
1259 }
1260
1261 return Ok;
1262 }
1263
1264// ignore index on the grouds that we only have one icon in a Unix file
1265bool wxFileTypeImpl::SetDefaultIcon(const wxString& strIcon /*= wxEmptyString*/, int /*index = 0*/)
1266 {
1267 if (strIcon.IsEmpty()) return FALSE;
1268 wxArrayString strExtensions;
1269 wxString strDesc;
1270
1271 wxMimeArrayString *entry = new wxMimeArrayString ();
1272
1273 wxArrayString strTypes;
1274 GetMimeTypes (strTypes);
1275 if (strTypes.GetCount() < 1) return FALSE;
1276
1277 size_t i;
1278 bool Ok = TRUE;
1279 for (i = 0; i < strTypes.GetCount(); i++)
1280 {
1281 if (!m_manager->DoAssociation (strTypes[i], strIcon, entry, strExtensions, strDesc))
1282 Ok = FALSE;
1283 }
1284
1285 return Ok;
1286 }
1287// ----------------------------------------------------------------------------
1288// wxMimeTypesManagerImpl (Unix)
1289// ----------------------------------------------------------------------------
1290
1291
1292wxMimeTypesManagerImpl::wxMimeTypesManagerImpl()
1293{
1294 m_initialized = FALSE;
1295 m_mailcapStylesInited = 0;
1296}
1297
1298// read system and user mailcaps and other files
1299void wxMimeTypesManagerImpl::Initialize(int mailcapStyles,
1300 const wxString& sExtraDir)
1301{
1302 // read mimecap amd mime.types
a06c1b9b
VZ
1303 if ( (mailcapStyles & wxMAILCAP_NETSCAPE) ||
1304 (mailcapStyles & wxMAILCAP_STANDARD) )
2b813b73
VZ
1305 GetMimeInfo(sExtraDir);
1306
1307 // read GNOME tables
1308 if ( mailcapStyles & wxMAILCAP_GNOME)
1309 GetGnomeMimeInfo(sExtraDir);
1310
1311 // read KDE tables
1312 if ( mailcapStyles & wxMAILCAP_KDE)
1313 GetKDEMimeInfo(sExtraDir);
1314
1315 m_mailcapStylesInited |= mailcapStyles;
1316}
1317
1318// clear data so you can read another group of WM files
1319void wxMimeTypesManagerImpl::ClearData()
1320{
1321 m_aTypes.Clear ();
1322 m_aIcons.Clear ();
1323 m_aExtensions.Clear ();
1324 m_aDescriptions.Clear ();
1325
1326 size_t cnt = m_aTypes.GetCount();
1327 for (size_t i = 0; i < cnt; i++)
1328 {
1329 m_aEntries[i]->Clear ();
1330 }
1331 m_aEntries.Clear ();
1332 m_mailcapStylesInited = 0;
1333}
1334
1335wxMimeTypesManagerImpl::~wxMimeTypesManagerImpl()
1336{
1337 ClearData(); // do we need to delete the ArrayStrings too to avoid a leak
1338
1339// delete m_aEntries //fix a leak here ?;
1340}
1341
1342
1343void wxMimeTypesManagerImpl::GetMimeInfo (const wxString& sExtraDir)
1344{
1345 // read this for netscape or Metamail formats
1346
1347 // directories where we look for mailcap and mime.types by default
1348 // used by netscape and pine and other mailers, using 2 different formats!
1349
1350 // (taken from metamail(1) sources)
1351 //
1352 // although RFC 1524 specifies the search path of
1353 // /etc/:/usr/etc:/usr/local/etc only, it doesn't hurt to search in more
1354 // places - OTOH, the RFC also says that this path can be changed with
1355 // MAILCAPS environment variable (containing the colon separated full
1356 // filenames to try) which is not done yet (TODO?)
1357
1358 wxString strHome = wxGetenv(wxT("HOME"));
1359
1360 wxArrayString dirs;
1361 dirs.Add ( wxT("/etc/") );
1362 dirs.Add ( wxT("/usr/etc/") );
1363 dirs.Add ( wxT("/usr/local/etc/") );
1364 dirs.Add ( wxT("/etc/mail/") );
1365 dirs.Add ( wxT("/usr/public/lib/") );
1366 dirs.Add ( strHome + wxT("/.") );
1367 if (!sExtraDir.IsEmpty()) dirs.Add ( sExtraDir + wxT("/") );
1368
1369 size_t nDirs = dirs.GetCount();
1370 for ( size_t nDir = 0; nDir < nDirs; nDir++ )
1371 {
1372 wxString file = dirs[nDir] + wxT("mailcap");
1373 if ( wxFile::Exists(file) ) {
1374 ReadMailcap(file);
1375 }
1376
1377 file = dirs[nDir] + wxT("mime.types");
1378 if ( wxFile::Exists(file) ) {
1379 ReadMimeTypes(file);
1380 }
1381 }
1382
1383}
1384
1385bool wxMimeTypesManagerImpl::WriteToMimeTypes (int index, bool delete_index)
1386{
1387 // check we have the right manager
a06c1b9b 1388 if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD) )
2b813b73
VZ
1389 return FALSE;
1390
1391 bool bTemp;
1392 wxString strHome = wxGetenv(wxT("HOME"));
1393
1394 // and now the users mailcap
1395 wxString strUserMailcap = strHome + wxT("/.mime.types");
1396
1397 wxMimeTextFile file;
1398 if ( wxFile::Exists(strUserMailcap) )
1399 {
1400 bTemp = file.Open(strUserMailcap);
1401 }
1402 else
1403 {
1404 if (delete_index) return FALSE;
1405 bTemp = file.Create(strUserMailcap);
1406 }
1407 if (bTemp)
1408 {
1409 int nIndex;
1410 // test for netscape's header and return FALSE if its found
1411 nIndex = file.pIndexOf (wxT("#--Netscape"));
1412 if (nIndex != wxNOT_FOUND)
1413 {
1414 wxASSERT_MSG(FALSE,wxT("Error in .mime.types \nTrying to mix Netscape and Metamail formats\nFile not modiifed"));
1415 return FALSE;
1416 }
1417 // write it in alternative format
1418 // get rid of unwanted entries
1419 wxString strType = m_aTypes[index];
1420 nIndex = file.pIndexOf (strType);
1421 // get rid of all the unwanted entries...
1422 if (nIndex != wxNOT_FOUND) file.CommentLine (nIndex);
1423
1424 if (!delete_index)
1425 {
1426 // add the new entries in
1427 wxString sTmp = strType.Append (wxT(' '), 40-strType.Len() );
1428 sTmp = sTmp + m_aExtensions[index];
1429 file.AddLine (sTmp);
1430 }
1431
1432
1433 bTemp = file.Write ();
1434 file.Close ();
1435 }
1436 return bTemp;
1437}
1438
1439bool wxMimeTypesManagerImpl::WriteToNSMimeTypes (int index, bool delete_index)
1440{
1441 //check we have the right managers
1442 if (! ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) )
1443 return FALSE;
1444
1445 bool bTemp;
1446 wxString strHome = wxGetenv(wxT("HOME"));
1447
1448 // and now the users mailcap
1449 wxString strUserMailcap = strHome + wxT("/.mime.types");
1450
1451 wxMimeTextFile file;
1452 if ( wxFile::Exists(strUserMailcap) )
1453 {
1454 bTemp = file.Open(strUserMailcap);
1455 }
1456 else
1457 {
1458 if (delete_index) return FALSE;
1459 bTemp = file.Create(strUserMailcap);
1460 }
1461 if (bTemp)
1462 {
1463
1464 // write it in the format that Netscape uses
1465 int nIndex;
1466 // test for netscape's header and insert if required...
1467 // this is a comment so use TRUE
1468 nIndex = file.pIndexOf (wxT("#--Netscape"), TRUE);
1469 if (nIndex == wxNOT_FOUND)
1470 {
1471 // either empty file or metamail format
1472 // at present we can't cope with mixed formats, so exit to preseve
1473 // metamail entreies
1474 if (file.GetLineCount () > 0)
1475 {
1476 wxASSERT_MSG(FALSE, wxT(".mime.types File not in Netscape format\nNo entries written to\n.mime.types or to .mailcap"));
1477 return FALSE;
1478 }
1479 file.InsertLine (wxT( "#--Netscape Communications Corporation MIME Information" ), 0);
1480 nIndex = 0;
1481 }
1482
1483 wxString strType = wxT("type=") + m_aTypes[index];
1484 nIndex = file.pIndexOf (strType);
1485 // get rid of all the unwanted entries...
1486 if (nIndex != wxNOT_FOUND)
1487 {
1488 wxString sOld = file[nIndex];
1489 while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
1490 {
1491 file.CommentLine(nIndex);
1492 sOld = file[nIndex];
1493 wxLogTrace(TRACE_MIME, wxT("--- Deleting from mime.types line '%d %s' ---"), nIndex, sOld.c_str());
1494 nIndex ++;
1495 }
1496 if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
1497 }
1498 else nIndex = (int) file.GetLineCount();
1499
1500 wxString sTmp = strType + wxT(" \\");
1501 if (!delete_index) file.InsertLine (sTmp, nIndex);
1502 if ( ! m_aDescriptions.Item(index).IsEmpty() )
1503 {
1504 sTmp = wxT("desc=\"") + m_aDescriptions[index]+ wxT("\" \\") ; //.trim ??
1505 if (!delete_index)
1506 {
1507 nIndex ++;
1508 file.InsertLine (sTmp, nIndex);
1509 }
1510 }
1511 wxString sExts = m_aExtensions.Item(index);
1512 sTmp = wxT("exts=\"") + sExts.Trim(FALSE).Trim() + wxT("\"");
1513 if (!delete_index)
1514 {
1515 nIndex ++;
1516 file.InsertLine (sTmp, nIndex);
1517 }
1518
1519 bTemp = file.Write ();
1520 file.Close ();
1521 }
1522 return bTemp;
1523}
1524
1525
1526bool wxMimeTypesManagerImpl::WriteToMailCap (int index, bool delete_index)
1527{
1528 //check we have the right managers
1529 if ( !( ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE) ||
a06c1b9b 1530 ( m_mailcapStylesInited & wxMAILCAP_STANDARD) ) )
2b813b73
VZ
1531 return FALSE;
1532
1533 bool bTemp;
1534 wxString strHome = wxGetenv(wxT("HOME"));
1535
1536 // and now the users mailcap
1537 wxString strUserMailcap = strHome + wxT("/.mailcap");
1538
1539 wxMimeTextFile file;
1540 if ( wxFile::Exists(strUserMailcap) )
1541 {
1542 bTemp = file.Open(strUserMailcap);
1543 }
be0a33fb 1544 else
2b813b73
VZ
1545 {
1546 if (delete_index) return FALSE;
1547 bTemp = file.Create(strUserMailcap);
1548 }
1549 if (bTemp)
1550 {
1551 // now got a file we can write to ....
1552 wxMimeArrayString * entries = m_aEntries[index];
1553 size_t iOpen = entries->pIndexOf(wxT("open"));
1554 wxString sCmd = entries->GetCmd(iOpen);
1555 wxString sTmp;
1556
1557 sTmp = m_aTypes[index];
1558 wxString sOld;
1559 int nIndex = file.pIndexOf(sTmp);
1560 // get rid of all the unwanted entries...
1561 if (nIndex == wxNOT_FOUND)
1562 {
1563 nIndex = (int) file.GetLineCount();
1564 }
1565 else
1566 {
1567 sOld = file[nIndex];
1568 wxLogTrace(TRACE_MIME, wxT("--- Deleting from mailcap line '%d' ---"), nIndex);
6dc6fda6 1569
2b813b73
VZ
1570 while ( (sOld.Contains(wxT("\\"))) && (nIndex < (int) file.GetLineCount()) )
1571 {
1572 file.CommentLine(nIndex);
1573 if (nIndex < (int) file.GetLineCount()) sOld = sOld + file[nIndex];
1574 }
1575 if (nIndex < (int) file.GetLineCount()) file.CommentLine (nIndex);
1576 }
6dc6fda6 1577
2b813b73 1578 sTmp = sTmp + wxT(";") + sCmd ; //includes wxT(" %s ");
b9517a0a 1579
2b813b73 1580 // write it in the format that Netscape uses (default)
a06c1b9b 1581 if (! ( m_mailcapStylesInited & wxMAILCAP_STANDARD ) )
2b813b73
VZ
1582 {
1583 if (! delete_index) file.InsertLine (sTmp, nIndex);
1584 nIndex ++;
1585 }
b9517a0a 1586
2b813b73
VZ
1587 // write extended format
1588 else
1589 {
1590 // todo FIX this code;
1591 // ii) lost entries
1592 // sOld holds all the entries, but our data store only has some
1593 // eg test= is not stored
1594
1595 // so far we have written the mimetype and command out
1596 wxStringTokenizer sT (sOld, wxT(";\\"));
1597 if (sT.CountTokens () > 2)
1598 {
1599 // first one mimetype; second one command, rest unknown...
1600 wxString s;
1601 s = sT.GetNextToken();
1602 s = sT.GetNextToken();
1603
1604 // first unknown
1605 s = sT.GetNextToken();
1606 while ( ! s.IsEmpty() )
1607 {
1608 bool bKnownToken = FALSE;
1609 if (s.Contains(wxT("description="))) bKnownToken = TRUE;
1610 if (s.Contains(wxT("x11-bitmap="))) bKnownToken = TRUE;
1611 size_t i;
1612 for (i=0; i < entries->GetCount(); i++)
1613 {
1614 if (s.Contains(entries->GetVerb(i))) bKnownToken = TRUE;
1615 }
1616 if (!bKnownToken)
1617 {
1618 sTmp = sTmp + wxT("; \\");
1619 file.InsertLine (sTmp, nIndex);
1620 sTmp = s;
1621 }
1622 s = sT.GetNextToken ();
1623 }
cdf339c9 1624
2b813b73 1625 }
5bd3a2da 1626
2b813b73
VZ
1627 if (! m_aDescriptions[index].IsEmpty() )
1628 {
1629 sTmp = sTmp + wxT("; \\");
1630 file.InsertLine (sTmp, nIndex);
1631 nIndex ++;
1632 sTmp = wxT(" description=\"") + m_aDescriptions[index] + wxT("\"");
1633 }
cdf339c9 1634
2b813b73
VZ
1635 if (! m_aIcons[index].IsEmpty() )
1636 {
1637 sTmp = sTmp + wxT("; \\");
1638 file.InsertLine (sTmp, nIndex);
1639 nIndex ++;
1640 sTmp = wxT(" x11-bitmap=\"") + m_aIcons[index] + wxT("\"");
1641 }
1642 if ( entries->GetCount() > 1 )
cdf339c9 1643
2b813b73
VZ
1644 {
1645 size_t i;
1646 for (i=0; i < entries->GetCount(); i++)
1647 if ( i != iOpen )
1648 {
1649 sTmp = sTmp + wxT("; \\");
1650 file.InsertLine (sTmp, nIndex);
1651 nIndex ++;
1652 sTmp = wxT(" ") + entries->Item(i);
1653 }
1654 }
b9517a0a 1655
2b813b73
VZ
1656 file.InsertLine (sTmp, nIndex);
1657 nIndex ++;
c93d6770 1658
b13d92d1 1659 }
2b813b73
VZ
1660 bTemp = file.Write ();
1661 file.Close ();
b13d92d1 1662 }
2b813b73 1663 return bTemp;
b13d92d1
VZ
1664}
1665
2b813b73
VZ
1666wxFileType *
1667wxMimeTypesManagerImpl::Associate(const wxFileTypeInfo& ftInfo)
b9517a0a 1668{
2b813b73 1669 InitIfNeeded();
b9517a0a 1670
2b813b73
VZ
1671 wxString strType = ftInfo.GetMimeType ();
1672 wxString strDesc = ftInfo.GetDescription ();
1673 wxString strIcon = ftInfo.GetIconFile ();
1674
1675 wxMimeArrayString *entry = new wxMimeArrayString ();
1676
1677 if ( ! ftInfo.GetOpenCommand().IsEmpty())
1678 entry->Add(wxT("open=") + ftInfo.GetOpenCommand () + wxT(" %s "));
1679 if ( ! ftInfo.GetPrintCommand ().IsEmpty())
1680 entry->Add(wxT("print=") + ftInfo.GetPrintCommand () + wxT(" %s "));
1681
1682 // now find where these extensions are in the data store and remove them
1683 wxArrayString sA_Exts = ftInfo.GetExtensions ();
1684 wxString sExt, sExtStore;
1685 size_t i, nIndex;
1686 for (i=0; i < sA_Exts.GetCount(); i++)
4d2976ad 1687 {
2b813b73
VZ
1688 sExt = sA_Exts.Item(i);
1689 //clean up to just a space before and after
1690 sExt.Trim().Trim(FALSE);
1691 sExt = wxT(' ') + sExt + wxT(' ');
1692 for (nIndex = 0; nIndex < m_aExtensions.GetCount(); nIndex ++)
1693 {
1694 sExtStore = m_aExtensions.Item(nIndex);
1695 if (sExtStore.Replace(sExt, wxT(" ") ) > 0) m_aExtensions.Item(nIndex) = sExtStore ;
b9517a0a
VZ
1696 }
1697
2b813b73 1698 }
b9517a0a 1699
2b813b73
VZ
1700 if ( !DoAssociation (strType, strIcon, entry, sA_Exts, strDesc) )
1701 return NULL;
4d2976ad 1702
2b813b73 1703 return GetFileTypeFromMimeType(strType);
4d2976ad
VS
1704}
1705
1706
2b813b73
VZ
1707bool wxMimeTypesManagerImpl::DoAssociation(const wxString& strType,
1708 const wxString& strIcon,
1709 wxMimeArrayString *entry,
1710 const wxArrayString& strExtensions,
1711 const wxString& strDesc)
b13d92d1 1712{
2b813b73 1713 int nIndex = AddToMimeData(strType, strIcon, entry, strExtensions, strDesc, TRUE);
b13d92d1 1714
2b813b73 1715 if ( nIndex == wxNOT_FOUND )
b13d92d1 1716 return FALSE;
b13d92d1 1717
2b813b73 1718 return WriteMimeInfo (nIndex, FALSE);
b13d92d1
VZ
1719}
1720
2b813b73 1721bool wxMimeTypesManagerImpl::WriteMimeInfo(int nIndex, bool delete_mime )
b13d92d1 1722{
2b813b73 1723 bool ok = TRUE;
b13d92d1 1724
a06c1b9b 1725 if ( m_mailcapStylesInited & wxMAILCAP_STANDARD )
2b813b73
VZ
1726 {
1727 // write in metamail format;
1728 if (WriteToMimeTypes (nIndex, delete_mime) )
1729 if ( WriteToMailCap (nIndex, delete_mime) )
1730 ok = FALSE;
b13d92d1 1731 }
2b813b73 1732 if ( m_mailcapStylesInited & wxMAILCAP_NETSCAPE )
b9517a0a 1733 {
2b813b73
VZ
1734 // write in netsacpe format;
1735 if (WriteToNSMimeTypes (nIndex, delete_mime) )
1736 if ( WriteToMailCap (nIndex, delete_mime) )
1737 ok = FALSE;
1738 }
1739 if (m_mailcapStylesInited & wxMAILCAP_GNOME)
1740 {
1741 // write in Gnome format;
1742 if (WriteGnomeMimeFile (nIndex, delete_mime) )
1743 if (WriteGnomeKeyFile (nIndex, delete_mime) )
1744 ok = FALSE;
1745 }
1746 if (m_mailcapStylesInited & wxMAILCAP_KDE)
1747 {
1748 // write in KDE format;
1749 if (WriteKDEMimeFile (nIndex, delete_mime) )
1750 ok = FALSE;
b9517a0a
VZ
1751 }
1752
2b813b73 1753 return ok;
a6c65e88
VZ
1754}
1755
2b813b73
VZ
1756int wxMimeTypesManagerImpl::AddToMimeData(const wxString& strType,
1757 const wxString& strIcon,
1758 wxMimeArrayString *entry,
1759 const wxArrayString& strExtensions,
1760 const wxString& strDesc,
1761 bool ReplaceExisting)
b13d92d1 1762{
2b813b73 1763 InitIfNeeded();
b13d92d1 1764
2b813b73
VZ
1765 wxLogTrace(TRACE_MIME, wxT("In Add to Mime data '%s' with %d entries and %d exts ---"),
1766 strType.c_str(), entry->GetCount(), strExtensions.GetCount() );
b13d92d1 1767
2b813b73
VZ
1768 // ensure mimetype is always lower case
1769 wxString mimeType = strType;
1770 mimeType.MakeLower();
1771 int nIndex = m_aTypes.Index(mimeType);
1772 if ( nIndex == wxNOT_FOUND )
1773 {
1774 // new file type
1775 m_aTypes.Add(mimeType);
1776 m_aIcons.Add(strIcon);
1777 m_aEntries.Add(entry);
1778 size_t i;
1779 // change nIndex so we can add to the correct line
1780 nIndex = m_aExtensions.Add(wxT(' '));
1781 for (i = 0; i < strExtensions.GetCount(); i ++)
1782 {
1783 if (! m_aExtensions.Item(nIndex).Contains(wxT(' ') + strExtensions.Item(i) + wxT(' ')))
1784 m_aExtensions.Item(nIndex) += strExtensions.Item(i) + wxT(' ');
b13d92d1 1785 }
2b813b73 1786 m_aDescriptions.Add(strDesc);
b13d92d1 1787
b13d92d1 1788 }
2b813b73
VZ
1789 else
1790 {
1791 // nIndex has the existing data
1792 // always add the extensions to this mimetype
1793 size_t i;
1794 for (i = 0; i < strExtensions.GetCount(); i ++)
1795 {
1796 if (! m_aExtensions.Item(nIndex).Contains(wxT(' ') + strExtensions.Item(i) + wxT(' ')))
1797 m_aExtensions.Item(nIndex) += strExtensions.Item(i) + wxT(' ');
1798 }
1799 if (ReplaceExisting)
1800 {
1801 // if new description change it
1802 if ( ! strDesc.IsEmpty())
1803 m_aDescriptions[nIndex] = strDesc;
1804
1805 // if new icon change it
1806 if ( ! strIcon.IsEmpty())
1807 m_aIcons[nIndex] = strIcon;
1808
1809 wxMimeArrayString *entryOld = m_aEntries[nIndex];
1810 // replace any matching entries...
1811 for (i=0; i < entry->GetCount(); i++)
1812 entryOld->ReplaceOrAddLineCmd (entry->GetVerb(i),
1813 entry->GetCmd (i) );
1814 }
1815 else
1816 {
1817 // add data we don't already have ...
1818 // if new description add only if none
1819 if ( ! strDesc.IsEmpty() && m_aDescriptions.Item(i).IsEmpty() )
1820 m_aDescriptions[nIndex] = strDesc;
1821
1822 // if new icon and no existing icon
1823 if ( ! strIcon.IsEmpty() && m_aIcons.Item(i). IsEmpty () )
1824 m_aIcons[nIndex] = strIcon;
1825
1826 wxMimeArrayString *entryOld = m_aEntries[nIndex];
1827 // add any new entries...
1828 for (i=0; i < entry->GetCount(); i++)
1829 {
1830 wxString sVerb = entry->GetVerb(i);
1831 if ( entryOld->pIndexOf ( sVerb ) == (size_t) wxNOT_FOUND )
1832 entryOld->Add (entry->Item(i));
1833 }
1834 }
b13d92d1 1835 }
4d2976ad 1836
2b813b73
VZ
1837 // check data integrity
1838 wxASSERT( m_aTypes.Count() == m_aEntries.Count() &&
1839 m_aTypes.Count() == m_aExtensions.Count() &&
1840 m_aTypes.Count() == m_aIcons.Count() &&
1841 m_aTypes.Count() == m_aDescriptions.Count() );
cf471cab 1842
2b813b73 1843 return nIndex;
cf471cab
VS
1844}
1845
1846
b13d92d1
VZ
1847wxFileType *
1848wxMimeTypesManagerImpl::GetFileTypeFromExtension(const wxString& ext)
1849{
2b813b73
VZ
1850 if (ext.IsEmpty() )
1851 return NULL;
1852
a6c65e88
VZ
1853 InitIfNeeded();
1854
2b813b73 1855 wxFileType *fileType = NULL;
1ee17e1c 1856 size_t count = m_aExtensions.GetCount();
2b813b73
VZ
1857 for ( size_t n = 0; n < count; n++ )
1858 {
1ee17e1c
VZ
1859 wxString extensions = m_aExtensions[n];
1860 while ( !extensions.IsEmpty() ) {
223d09f6
KB
1861 wxString field = extensions.BeforeFirst(wxT(' '));
1862 extensions = extensions.AfterFirst(wxT(' '));
1ee17e1c
VZ
1863
1864 // consider extensions as not being case-sensitive
2b813b73
VZ
1865 if ( field.IsSameAs(ext, FALSE /* no case */) )
1866 {
1ee17e1c 1867 // found
4d2976ad 1868 if (fileType == NULL) fileType = new wxFileType;
1ee17e1c 1869 fileType->m_impl->Init(this, n);
4d2976ad 1870 // adds this mime type to _list_ of mime types with this extension
1ee17e1c
VZ
1871 }
1872 }
1873 }
b13d92d1 1874
4d2976ad 1875 return fileType;
b13d92d1
VZ
1876}
1877
1878wxFileType *
1879wxMimeTypesManagerImpl::GetFileTypeFromMimeType(const wxString& mimeType)
1880{
a6c65e88
VZ
1881 InitIfNeeded();
1882
2b813b73 1883 wxFileType * fileType = NULL;
b13d92d1
VZ
1884 // mime types are not case-sensitive
1885 wxString mimetype(mimeType);
1886 mimetype.MakeLower();
1887
1888 // first look for an exact match
1889 int index = m_aTypes.Index(mimetype);
2b813b73
VZ
1890 if ( index != wxNOT_FOUND )
1891 {
1892 fileType = new wxFileType;
1893 fileType->m_impl->Init(this, index);
1894 }
1895
1896 // then try to find "text/*" as match for "text/plain" (for example)
1897 // NB: if mimeType doesn't contain '/' at all, BeforeFirst() will return
1898 // the whole string - ok.
1899
1900 index = wxNOT_FOUND;
1901 wxString strCategory = mimetype.BeforeFirst(wxT('/'));
1902
1903 size_t nCount = m_aTypes.Count();
1904 for ( size_t n = 0; n < nCount; n++ ) {
1905 if ( (m_aTypes[n].BeforeFirst(wxT('/')) == strCategory ) &&
1906 m_aTypes[n].AfterFirst(wxT('/')) == wxT("*") ) {
1907 index = n;
1908 break;
b13d92d1 1909 }
2b813b73 1910
b13d92d1
VZ
1911 }
1912
2b813b73
VZ
1913 if ( index != wxNOT_FOUND )
1914 {
1915 fileType = new wxFileType;
b13d92d1 1916 fileType->m_impl->Init(this, index);
b13d92d1 1917 }
2b813b73
VZ
1918 return fileType;
1919}
1920
1921
1922wxString wxMimeTypesManagerImpl::GetCommand(const wxString & verb, size_t nIndex) const
1923{
1924 wxString command, testcmd, sV, sTmp;
1925 sV = verb + wxT("=");
1926 // list of verb = command pairs for this mimetype
1927 wxMimeArrayString * sPairs = m_aEntries [nIndex];
1928
1929 size_t i;
1930 for ( i = 0; i < sPairs->GetCount () ; i++ )
1931 {
1932 sTmp = sPairs->Item (i);
1933 if ( sTmp.Contains(sV) ) command = sTmp.AfterFirst(wxT('='));
b13d92d1 1934 }
2b813b73 1935 return command;
b13d92d1
VZ
1936}
1937
8e124873
VZ
1938void wxMimeTypesManagerImpl::AddFallback(const wxFileTypeInfo& filetype)
1939{
a6c65e88
VZ
1940 InitIfNeeded();
1941
3f1aaa16 1942 wxString extensions;
8e124873
VZ
1943 const wxArrayString& exts = filetype.GetExtensions();
1944 size_t nExts = exts.GetCount();
1945 for ( size_t nExt = 0; nExt < nExts; nExt++ ) {
1946 if ( nExt > 0 ) {
223d09f6 1947 extensions += wxT(' ');
8e124873
VZ
1948 }
1949 extensions += exts[nExt];
1950 }
1951
1952 AddMimeTypeInfo(filetype.GetMimeType(),
1953 extensions,
1954 filetype.GetDescription());
1955
1956 AddMailcapInfo(filetype.GetMimeType(),
1957 filetype.GetOpenCommand(),
1958 filetype.GetPrintCommand(),
223d09f6 1959 wxT(""),
8e124873
VZ
1960 filetype.GetDescription());
1961}
1962
1963void wxMimeTypesManagerImpl::AddMimeTypeInfo(const wxString& strMimeType,
1964 const wxString& strExtensions,
1965 const wxString& strDesc)
1966{
2b813b73
VZ
1967 // reading mailcap may find image/* , while
1968 // reading mime.types finds image/gif and no match is made
1969 // this means all the get functions don't work fix this
1970 wxString strIcon;
1971 wxString sTmp = strExtensions;
1972 wxMimeArrayString * entry = new wxMimeArrayString () ;
a6c65e88 1973
2b813b73
VZ
1974 wxArrayString sExts;
1975 sTmp.Trim().Trim(FALSE);
1976
1977 while (!sTmp.IsEmpty())
1978 {
1979 sExts.Add (sTmp.AfterLast(wxT(' ')));
1980 sTmp = sTmp.BeforeLast(wxT(' '));
8e124873 1981 }
2b813b73
VZ
1982
1983 AddToMimeData (strMimeType, strIcon, entry, sExts, strDesc, (bool)TRUE);
8e124873
VZ
1984}
1985
1986void wxMimeTypesManagerImpl::AddMailcapInfo(const wxString& strType,
1987 const wxString& strOpenCmd,
1988 const wxString& strPrintCmd,
1989 const wxString& strTest,
1990 const wxString& strDesc)
1991{
a6c65e88
VZ
1992 InitIfNeeded();
1993
2b813b73
VZ
1994 wxMimeArrayString *entry = new wxMimeArrayString;
1995 entry->Add(wxT("open=") + strOpenCmd);
1996 entry->Add(wxT("print=") + strPrintCmd);
1997 entry->Add(wxT("test=") + strTest);
8e124873 1998
2b813b73
VZ
1999 wxString strIcon;
2000 wxArrayString strExtensions;
2001
2002 AddToMimeData (strType, strIcon, entry, strExtensions, strDesc, TRUE);
8e124873 2003
8e124873
VZ
2004}
2005
cc385968 2006bool wxMimeTypesManagerImpl::ReadMimeTypes(const wxString& strFileName)
b13d92d1 2007{
f6bcfd97
BP
2008 wxLogTrace(TRACE_MIME, wxT("--- Parsing mime.types file '%s' ---"),
2009 strFileName.c_str());
b13d92d1
VZ
2010
2011 wxTextFile file(strFileName);
2012 if ( !file.Open() )
cc385968 2013 return FALSE;
b13d92d1
VZ
2014
2015 // the information we extract
2016 wxString strMimeType, strDesc, strExtensions;
2017
2018 size_t nLineCount = file.GetLineCount();
50920146 2019 const wxChar *pc = NULL;
b13d92d1 2020 for ( size_t nLine = 0; nLine < nLineCount; nLine++ ) {
22b4634c
VZ
2021 if ( pc == NULL ) {
2022 // now we're at the start of the line
2023 pc = file[nLine].c_str();
2024 }
2025 else {
2026 // we didn't finish with the previous line yet
2027 nLine--;
2028 }
b13d92d1
VZ
2029
2030 // skip whitespace
50920146 2031 while ( wxIsspace(*pc) )
b13d92d1
VZ
2032 pc++;
2033
54acce90
VZ
2034 // comment or blank line?
2035 if ( *pc == wxT('#') || !*pc ) {
22b4634c
VZ
2036 // skip the whole line
2037 pc = NULL;
b13d92d1 2038 continue;
22b4634c 2039 }
b13d92d1
VZ
2040
2041 // detect file format
223d09f6 2042 const wxChar *pEqualSign = wxStrchr(pc, wxT('='));
b13d92d1
VZ
2043 if ( pEqualSign == NULL ) {
2044 // brief format
2045 // ------------
2046
2047 // first field is mime type
223d09f6 2048 for ( strMimeType.Empty(); !wxIsspace(*pc) && *pc != wxT('\0'); pc++ ) {
b13d92d1
VZ
2049 strMimeType += *pc;
2050 }
2051
2052 // skip whitespace
50920146 2053 while ( wxIsspace(*pc) )
b13d92d1
VZ
2054 pc++;
2055
2056 // take all the rest of the string
2057 strExtensions = pc;
2058
2059 // no description...
2060 strDesc.Empty();
2061 }
2062 else {
2063 // expanded format
2064 // ---------------
2065
2066 // the string on the left of '=' is the field name
2067 wxString strLHS(pc, pEqualSign - pc);
2068
2069 // eat whitespace
50920146 2070 for ( pc = pEqualSign + 1; wxIsspace(*pc); pc++ )
2b813b73 2071 ;
b13d92d1 2072
50920146 2073 const wxChar *pEnd;
223d09f6 2074 if ( *pc == wxT('"') ) {
b13d92d1 2075 // the string is quoted and ends at the matching quote
223d09f6 2076 pEnd = wxStrchr(++pc, wxT('"'));
b13d92d1
VZ
2077 if ( pEnd == NULL ) {
2078 wxLogWarning(_("Mime.types file %s, line %d: unterminated "
2079 "quoted string."),
2080 strFileName.c_str(), nLine + 1);
2081 }
2082 }
2083 else {
8862e11b
VZ
2084 // unquoted string ends at the first space or at the end of
2085 // line
2086 for ( pEnd = pc; *pEnd && !wxIsspace(*pEnd); pEnd++ )
2b813b73 2087 ;
b13d92d1
VZ
2088 }
2089
2090 // now we have the RHS (field value)
2091 wxString strRHS(pc, pEnd - pc);
2092
22b4634c 2093 // check what follows this entry
223d09f6 2094 if ( *pEnd == wxT('"') ) {
b13d92d1
VZ
2095 // skip this quote
2096 pEnd++;
2097 }
2098
50920146 2099 for ( pc = pEnd; wxIsspace(*pc); pc++ )
2b813b73 2100 ;
b13d92d1 2101
22b4634c
VZ
2102 // if there is something left, it may be either a '\\' to continue
2103 // the line or the next field of the same entry
223d09f6 2104 bool entryEnded = *pc == wxT('\0'),
22b4634c
VZ
2105 nextFieldOnSameLine = FALSE;
2106 if ( !entryEnded ) {
223d09f6 2107 nextFieldOnSameLine = ((*pc != wxT('\\')) || (pc[1] != wxT('\0')));
b13d92d1 2108 }
b13d92d1
VZ
2109
2110 // now see what we got
223d09f6 2111 if ( strLHS == wxT("type") ) {
b13d92d1
VZ
2112 strMimeType = strRHS;
2113 }
223d09f6 2114 else if ( strLHS == wxT("desc") ) {
b13d92d1
VZ
2115 strDesc = strRHS;
2116 }
223d09f6 2117 else if ( strLHS == wxT("exts") ) {
b13d92d1
VZ
2118 strExtensions = strRHS;
2119 }
2120 else {
2121 wxLogWarning(_("Unknown field in file %s, line %d: '%s'."),
2122 strFileName.c_str(), nLine + 1, strLHS.c_str());
2123 }
2124
2125 if ( !entryEnded ) {
22b4634c
VZ
2126 if ( !nextFieldOnSameLine )
2127 pc = NULL;
2128 //else: don't reset it
2129
2130 // as we don't reset strMimeType, the next field in this entry
b13d92d1 2131 // will be interpreted correctly.
22b4634c 2132
b13d92d1
VZ
2133 continue;
2134 }
2135 }
2136
a6c65e88
VZ
2137 // depending on the format (Mosaic or Netscape) either space or comma
2138 // is used to separate the extensions
223d09f6 2139 strExtensions.Replace(wxT(","), wxT(" "));
a1d8eaf7
VZ
2140
2141 // also deal with the leading dot
1b986aef
VZ
2142 if ( !strExtensions.IsEmpty() && strExtensions[0u] == wxT('.') )
2143 {
a1d8eaf7
VZ
2144 strExtensions.erase(0, 1);
2145 }
2146
2b813b73
VZ
2147 wxLogTrace(TRACE_MIME, wxT("--- Found Mimetype '%s' ---"),
2148 strMimeType.c_str());
2149
8e124873 2150 AddMimeTypeInfo(strMimeType, strExtensions, strDesc);
22b4634c
VZ
2151
2152 // finished with this line
2153 pc = NULL;
b13d92d1
VZ
2154 }
2155
cc385968 2156 return TRUE;
b13d92d1
VZ
2157}
2158
cc385968
VZ
2159bool wxMimeTypesManagerImpl::ReadMailcap(const wxString& strFileName,
2160 bool fallback)
b13d92d1 2161{
2b813b73 2162// wxLog::AddTraceMask (TRACE_MIME);
f6bcfd97
BP
2163 wxLogTrace(TRACE_MIME, wxT("--- Parsing mailcap file '%s' ---"),
2164 strFileName.c_str());
b13d92d1
VZ
2165
2166 wxTextFile file(strFileName);
2167 if ( !file.Open() )
cc385968 2168 return FALSE;
b13d92d1 2169
cc385968
VZ
2170 // see the comments near the end of function for the reason we need these
2171 // variables (search for the next occurence of them)
2172 // indices of MIME types (in m_aTypes) we already found in this file
b13d92d1 2173 wxArrayInt aEntryIndices;
cc385968
VZ
2174 // aLastIndices[n] is the index of last element in
2175 // m_aEntries[aEntryIndices[n]] from this file
2b813b73 2176 // wxArrayInt aLastIndices;
b13d92d1
VZ
2177
2178 size_t nLineCount = file.GetLineCount();
2179 for ( size_t nLine = 0; nLine < nLineCount; nLine++ ) {
2180 // now we're at the start of the line
50920146 2181 const wxChar *pc = file[nLine].c_str();
b13d92d1
VZ
2182
2183 // skip whitespace
50920146 2184 while ( wxIsspace(*pc) )
b13d92d1
VZ
2185 pc++;
2186
2187 // comment or empty string?
223d09f6 2188 if ( *pc == wxT('#') || *pc == wxT('\0') )
b13d92d1
VZ
2189 continue;
2190
2191 // no, do parse
2192
2193 // what field are we currently in? The first 2 are fixed and there may
2194 // be an arbitrary number of other fields -- currently, we are not
2195 // interested in any of them, but we should parse them as well...
2196 enum
2197 {
2198 Field_Type,
2199 Field_OpenCmd,
2200 Field_Other
2201 } currentToken = Field_Type;
2202
2203 // the flags and field values on the current line
8fc613f1
RR
2204 bool needsterminal = FALSE,
2205 copiousoutput = FALSE;
53e3052c 2206 wxMimeArrayString *entry = NULL; // suppress compiler warning
2b813b73 2207
b13d92d1
VZ
2208 wxString strType,
2209 strOpenCmd,
2b813b73 2210 strIcon,
b13d92d1
VZ
2211 strTest,
2212 strDesc,
2213 curField; // accumulator
6e358ae7 2214 bool cont = TRUE;
2b813b73 2215 bool test_passed = TRUE;
6e358ae7 2216 while ( cont ) {
b13d92d1 2217 switch ( *pc ) {
223d09f6 2218 case wxT('\\'):
b13d92d1
VZ
2219 // interpret the next character literally (notice that
2220 // backslash can be used for line continuation)
223d09f6 2221 if ( *++pc == wxT('\0') ) {
6e358ae7
VZ
2222 // fetch the next line if there is one
2223 if ( nLine == nLineCount - 1 ) {
2224 // something is wrong, bail out
2225 cont = FALSE;
2226
2227 wxLogDebug(wxT("Mailcap file %s, line %d: "
2228 "'\\' on the end of the last line "
2229 "ignored."),
2230 strFileName.c_str(),
2231 nLine + 1);
2232 }
2233 else {
2234 // pass to the beginning of the next line
2235 pc = file[++nLine].c_str();
2236
2237 // skip pc++ at the end of the loop
2238 continue;
2239 }
b13d92d1
VZ
2240 }
2241 else {
2242 // just a normal character
2243 curField += *pc;
2244 }
2245 break;
2246
223d09f6 2247 case wxT('\0'):
b13d92d1
VZ
2248 cont = FALSE; // end of line reached, exit the loop
2249
2250 // fall through
2251
223d09f6 2252 case wxT(';'):
b13d92d1
VZ
2253 // store this field and start looking for the next one
2254
2255 // trim whitespaces from both sides
2256 curField.Trim(TRUE).Trim(FALSE);
2257
2258 switch ( currentToken ) {
2259 case Field_Type:
2260 strType = curField;
6e358ae7
VZ
2261 if ( strType.empty() ) {
2262 // I don't think that this is a valid mailcap
2263 // entry, but try to interpret it somehow
2264 strType = _T('*');
2265 }
2266
223d09f6 2267 if ( strType.Find(wxT('/')) == wxNOT_FOUND ) {
b13d92d1 2268 // we interpret "type" as "type/*"
223d09f6 2269 strType += wxT("/*");
b13d92d1
VZ
2270 }
2271
2272 currentToken = Field_OpenCmd;
2273 break;
2274
2275 case Field_OpenCmd:
2276 strOpenCmd = curField;
2b813b73
VZ
2277 entry = new wxMimeArrayString ();
2278 entry->Add(wxT("open=") + strOpenCmd);
b13d92d1
VZ
2279
2280 currentToken = Field_Other;
2281 break;
2282
2283 case Field_Other:
6e358ae7 2284 if ( !curField.empty() ) {
b13d92d1
VZ
2285 // "good" mailcap entry?
2286 bool ok = TRUE;
2287
2b813b73
VZ
2288 if ( IsKnownUnimportantField(curField) ) ok = FALSE;
2289
b13d92d1 2290 // is this something of the form foo=bar?
223d09f6 2291 const wxChar *pEq = wxStrchr(curField, wxT('='));
2b813b73
VZ
2292 if (ok)
2293 {
2294 if ( pEq != NULL )
2295 {
223d09f6
KB
2296 wxString lhs = curField.BeforeFirst(wxT('=')),
2297 rhs = curField.AfterFirst(wxT('='));
b13d92d1
VZ
2298
2299 lhs.Trim(TRUE); // from right
2300 rhs.Trim(FALSE); // from left
2301
b13d92d1 2302 // it might be quoted
2b813b73
VZ
2303 if ( rhs[0u] == wxT('"') && rhs.Last() == wxT('"') )
2304 {
2305 wxString sTmp = wxString(rhs.c_str() + 1, rhs.Len() - 2);
2306 rhs = sTmp;
2307 }
2308 bool verbfound = TRUE;
2309 if ( lhs.Contains (wxT("test")))
2310 {
2311 if ( ! rhs.IsEmpty() )
2312 {
2313 if ( wxSystem(rhs) == 0 ) {
2314 // ok, test passed
2315 test_passed = TRUE;
2316 wxLogTrace(TRACE_MIME,
2317 wxT("Test '%s' for mime type '%s' succeeded."),
2318 rhs.c_str(), strType.c_str());
2319
b13d92d1
VZ
2320 }
2321 else {
2b813b73
VZ
2322 test_passed = FALSE;
2323 wxLogTrace(TRACE_MIME,
2324 wxT("Test '%s' for mime type '%s' failed."),
2325 rhs.c_str(), strType.c_str());
2326 }
2327 }
2328 verbfound = FALSE;
2329 }
2330 if ( lhs.Contains (wxT("desc")))
2331 {
b13d92d1 2332 strDesc = rhs;
2b813b73 2333 verbfound = FALSE;
b13d92d1 2334 }
2b813b73
VZ
2335 if ( lhs.Contains (wxT("x11-bitmap")))
2336 {
2337 strIcon = rhs;
2338 verbfound = FALSE;
b13d92d1 2339 }
2b813b73
VZ
2340 if ( lhs.Contains (wxT("notes")))
2341 {
2342 // ignore
2343 verbfound = FALSE;
b13d92d1 2344 }
2b813b73
VZ
2345 if (verbfound) entry->Add ( lhs + wxT('=') + rhs );
2346 ok = TRUE;
2347 }
2348 else
2349 {
b13d92d1 2350 // no, it's a simple flag
2b813b73 2351 if ( curField == wxT("needsterminal") ) {
b13d92d1 2352 needsterminal = TRUE;
2b813b73
VZ
2353 ok = TRUE;
2354 }
2355 if ( curField == wxT("copiousoutput")) {
e1e9ea40
VZ
2356 // copiousoutput impies that the
2357 // viewer is a console program
2358 needsterminal =
2b813b73
VZ
2359 copiousoutput =
2360 ok = TRUE;
b13d92d1
VZ
2361
2362 if ( !ok )
2363 {
54acce90
VZ
2364 // don't flood the user with error
2365 // messages if we don't understand
2366 // something in his mailcap, but give
2367 // them in debug mode because this might
2368 // be useful for the programmer
2369 wxLogDebug
2370 (
2371 wxT("Mailcap file %s, line %d: "
2372 "unknown field '%s' for the "
2373 "MIME type '%s' ignored."),
2374 strFileName.c_str(),
2375 nLine + 1,
2376 curField.c_str(),
2377 strType.c_str()
2378 );
2b813b73
VZ
2379
2380 }
2381
2382 }
2383
54acce90 2384 }
2b813b73 2385
b13d92d1 2386 }
2b813b73 2387
b13d92d1 2388 }
2b813b73 2389
b13d92d1
VZ
2390
2391 // it already has this value
2392 //currentToken = Field_Other;
2393 break;
2394
2395 default:
223d09f6 2396 wxFAIL_MSG(wxT("unknown field type in mailcap"));
b13d92d1
VZ
2397 }
2398
2399 // next token starts immediately after ';'
2400 curField.Empty();
2401 break;
2402
2403 default:
2404 curField += *pc;
2405 }
6e358ae7
VZ
2406
2407 // continue in the same line
2408 pc++;
b13d92d1
VZ
2409 }
2410
2411 // check that we really read something reasonable
2412 if ( currentToken == Field_Type || currentToken == Field_OpenCmd ) {
2413 wxLogWarning(_("Mailcap file %s, line %d: incomplete entry "
2414 "ignored."),
2415 strFileName.c_str(), nLine + 1);
2416 }
2417 else {
e1e9ea40
VZ
2418 // support for flags:
2419 // 1. create an xterm for 'needsterminal'
2420 // 2. append "| $PAGER" for 'copiousoutput'
a6c65e88
VZ
2421 //
2422 // Note that the RFC says that having both needsterminal and
2423 // copiousoutput is probably a mistake, so it seems that running
2424 // programs with copiousoutput inside an xterm as it is done now
2425 // is a bad idea (FIXME)
2b813b73
VZ
2426 if ( copiousoutput )
2427 {
e1e9ea40
VZ
2428 const wxChar *p = wxGetenv(_T("PAGER"));
2429 strOpenCmd << _T(" | ") << (p ? p : _T("more"));
2b813b73 2430 wxLogTrace(TRACE_MIME, wxT("Replacing .(for pager)...") + entry->Item(0u) + wxT("with") + strOpenCmd );
e1e9ea40 2431
2b813b73 2432 entry->ReplaceOrAddLineCmd (wxString(wxT("open")), strOpenCmd );
e1e9ea40
VZ
2433 }
2434
2b813b73
VZ
2435 if ( needsterminal )
2436 {
2437 strOpenCmd.Printf(_T("xterm -e sh -c '%s'"), strOpenCmd.c_str());
2438 wxLogTrace(TRACE_MIME, wxT("Replacing .(for needs term)...") + entry->Item(0u) + wxT("with") + strOpenCmd );
2439
2440 entry->ReplaceOrAddLineCmd (wxString(wxT("open")), strOpenCmd );
2441 }
b13d92d1 2442
8e124873
VZ
2443 // NB: because of complications below (we must get entries priority
2444 // right), we can't use AddMailcapInfo() here, unfortunately.
2b813b73
VZ
2445 if ( test_passed )
2446 {
b13d92d1 2447 strType.MakeLower();
2b813b73
VZ
2448 bool overwrite = TRUE;
2449 int entryIndex ;
2450 if (fallback)
2451 overwrite = FALSE;
cc385968 2452 else
2b813b73
VZ
2453 {
2454 int nIndex = m_aTypes.Index(strType);
2455 entryIndex = aEntryIndices.Index(nIndex);
2456 if ( entryIndex == wxNOT_FOUND )
2457 {
2458 //check this fix
2459 // first time in this file, so replace the icons, entries
2460 // and description (no extensions to replace so ignore these
2461 overwrite = TRUE;
cc385968 2462 aEntryIndices.Add(nIndex);
2b813b73 2463 //aLastIndices.Add(0);
cc385968
VZ
2464 }
2465 else {
2466 // not the first time in _this_ file
2b813b73
VZ
2467 // so we don't want to overwrite
2468 // existing entries,but want to add to them
2469 // so we don't alter the mimetype
cc385968 2470 // the indices were shifted by 1
2b813b73 2471 overwrite = FALSE;
b13d92d1
VZ
2472 }
2473
2b813b73 2474
b13d92d1 2475 }
2b813b73
VZ
2476 wxArrayString strExtensions;
2477 AddToMimeData (strType, strIcon, entry, strExtensions, strDesc, !overwrite );
2478 test_passed = TRUE;
b13d92d1
VZ
2479 }
2480 }
2481
b13d92d1 2482 }
cc385968
VZ
2483
2484 return TRUE;
b13d92d1
VZ
2485}
2486
696e1ea0 2487size_t wxMimeTypesManagerImpl::EnumAllFileTypes(wxArrayString& mimetypes)
1b986aef 2488{
a6c65e88
VZ
2489 InitIfNeeded();
2490
54acce90
VZ
2491 mimetypes.Empty();
2492
2493 wxString type;
2494 size_t count = m_aTypes.GetCount();
2495 for ( size_t n = 0; n < count; n++ )
2496 {
2497 // don't return template types from here (i.e. anything containg '*')
2498 type = m_aTypes[n];
2499 if ( type.Find(_T('*')) == wxNOT_FOUND )
2500 {
2501 mimetypes.Add(type);
2502 }
2503 }
1b986aef 2504
54acce90 2505 return mimetypes.GetCount();
1b986aef
VZ
2506}
2507
a6c65e88
VZ
2508// ----------------------------------------------------------------------------
2509// writing to MIME type files
2510// ----------------------------------------------------------------------------
2511
2b813b73 2512bool wxMimeTypesManagerImpl::Unassociate(wxFileType *ft)
a6c65e88 2513{
2b813b73
VZ
2514 wxArrayString sMimeTypes;
2515 ft->GetMimeTypes (sMimeTypes);
a6c65e88 2516
2b813b73
VZ
2517 wxString sMime;
2518 size_t i;
2519 for (i = 0; i < sMimeTypes.GetCount(); i ++)
2520 {
2521 sMime = sMimeTypes.Item(i);
2522 int nIndex = m_aTypes.Index (sMime);
2523 if ( nIndex == wxNOT_FOUND)
2524 {
2525 // error if we get here ??
2526 return FALSE;
2527 }
2528 else
2529 {
2530 WriteMimeInfo(nIndex, TRUE );
2531 m_aTypes.Remove (nIndex);
2532 m_aEntries.Remove (nIndex);
2533 m_aExtensions.Remove (nIndex);
2534 m_aDescriptions.Remove (nIndex);
2535 m_aIcons.Remove (nIndex);
2536 }
2537 }
2538 // check data integrity
2539 wxASSERT( m_aTypes.Count() == m_aEntries.Count() &&
2540 m_aTypes.Count() == m_aExtensions.Count() &&
2541 m_aTypes.Count() == m_aIcons.Count() &&
2542 m_aTypes.Count() == m_aDescriptions.Count() );
2543
2544 return TRUE;
a6c65e88
VZ
2545}
2546
f6bcfd97
BP
2547// ----------------------------------------------------------------------------
2548// private functions
2549// ----------------------------------------------------------------------------
2550
2551static bool IsKnownUnimportantField(const wxString& fieldAll)
2552{
2553 static const wxChar *knownFields[] =
2554 {
2555 _T("x-mozilla-flags"),
2556 _T("nametemplate"),
2557 _T("textualnewlines"),
2558 };
2559
2560 wxString field = fieldAll.BeforeFirst(_T('='));
2561 for ( size_t n = 0; n < WXSIZEOF(knownFields); n++ )
2562 {
2563 if ( field.CmpNoCase(knownFields[n]) == 0 )
2564 return TRUE;
2565 }
2566
2567 return FALSE;
2568}
2569
8e124873 2570#endif
ce4169a4 2571 // wxUSE_FILE && wxUSE_TEXTFILE
b13d92d1 2572