]> git.saurik.com Git - wxWidgets.git/blob - src/common/mimecmn.cpp
starting blend modes for Core Graphics
[wxWidgets.git] / src / common / mimecmn.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: common/mimecmn.cpp
3 // Purpose: classes and functions to manage MIME types
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Chris Elliott (biol75@york.ac.uk) 5 Dec 00: write support for Win32
7 // Created: 23.09.98
8 // RCS-ID: $Id$
9 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
10 // Licence: wxWindows licence (part of wxExtra library)
11 /////////////////////////////////////////////////////////////////////////////
12
13 // ============================================================================
14 // declarations
15 // ============================================================================
16
17 // ----------------------------------------------------------------------------
18 // headers
19 // ----------------------------------------------------------------------------
20
21 // for compilers that support precompilation, includes "wx.h".
22 #include "wx/wxprec.h"
23
24 #ifdef __BORLANDC__
25 #pragma hdrstop
26 #endif
27
28 #if wxUSE_MIMETYPE
29
30 #ifndef WX_PRECOMP
31 #include "wx/string.h"
32 #endif //WX_PRECOMP
33
34 #include "wx/module.h"
35 #include "wx/log.h"
36 #include "wx/file.h"
37 #include "wx/iconloc.h"
38 #include "wx/intl.h"
39 #include "wx/dynarray.h"
40 #include "wx/confbase.h"
41
42 #include "wx/mimetype.h"
43
44 // other standard headers
45 #include <ctype.h>
46
47 // implementation classes:
48 #if defined(__WXMSW__)
49 #include "wx/msw/mimetype.h"
50 #elif defined(__WXMAC__)
51 #include "wx/mac/mimetype.h"
52 #elif defined(__WXPM__) || defined (__EMX__)
53 #include "wx/os2/mimetype.h"
54 #undef __UNIX__
55 #elif defined(__DOS__)
56 #include "wx/msdos/mimetype.h"
57 #else // Unix
58 #include "wx/unix/mimetype.h"
59 #endif
60
61 // ============================================================================
62 // common classes
63 // ============================================================================
64
65 // ----------------------------------------------------------------------------
66 // wxFileTypeInfo
67 // ----------------------------------------------------------------------------
68
69 wxFileTypeInfo::wxFileTypeInfo(const wxChar *mimeType,
70 const wxChar *openCmd,
71 const wxChar *printCmd,
72 const wxChar *desc,
73 ...)
74 : m_mimeType(mimeType),
75 m_openCmd(openCmd),
76 m_printCmd(printCmd),
77 m_desc(desc)
78 {
79 va_list argptr;
80 va_start(argptr, desc);
81
82 for ( ;; )
83 {
84 // icc gives this warning in its own va_arg() macro, argh
85 #ifdef __INTELC__
86 #pragma warning(push)
87 #pragma warning(disable: 1684)
88 #endif
89
90 const wxChar *ext = va_arg(argptr, const wxChar *);
91
92 #ifdef __INTELC__
93 #pragma warning(pop)
94 #endif
95 if ( !ext )
96 {
97 // NULL terminates the list
98 break;
99 }
100
101 m_exts.Add(ext);
102 }
103
104 va_end(argptr);
105 }
106
107
108 wxFileTypeInfo::wxFileTypeInfo(const wxArrayString& sArray)
109 {
110 m_mimeType = sArray [0u];
111 m_openCmd = sArray [1u];
112 m_printCmd = sArray [2u];
113 m_desc = sArray [3u];
114
115 size_t count = sArray.GetCount();
116 for ( size_t i = 4; i < count; i++ )
117 {
118 m_exts.Add(sArray[i]);
119 }
120 }
121
122 #include "wx/arrimpl.cpp"
123 WX_DEFINE_OBJARRAY(wxArrayFileTypeInfo)
124
125 // ============================================================================
126 // implementation of the wrapper classes
127 // ============================================================================
128
129 // ----------------------------------------------------------------------------
130 // wxFileType
131 // ----------------------------------------------------------------------------
132
133 /* static */
134 wxString wxFileType::ExpandCommand(const wxString& command,
135 const wxFileType::MessageParameters& params)
136 {
137 bool hasFilename = false;
138
139 wxString str;
140 for ( const wxChar *pc = command.c_str(); *pc != wxT('\0'); pc++ ) {
141 if ( *pc == wxT('%') ) {
142 switch ( *++pc ) {
143 case wxT('s'):
144 // '%s' expands into file name (quoted because it might
145 // contain spaces) - except if there are already quotes
146 // there because otherwise some programs may get confused
147 // by double double quotes
148 #if 0
149 if ( *(pc - 2) == wxT('"') )
150 str << params.GetFileName();
151 else
152 str << wxT('"') << params.GetFileName() << wxT('"');
153 #endif
154 str << params.GetFileName();
155 hasFilename = true;
156 break;
157
158 case wxT('t'):
159 // '%t' expands into MIME type (quote it too just to be
160 // consistent)
161 str << wxT('\'') << params.GetMimeType() << wxT('\'');
162 break;
163
164 case wxT('{'):
165 {
166 const wxChar *pEnd = wxStrchr(pc, wxT('}'));
167 if ( pEnd == NULL ) {
168 wxString mimetype;
169 wxLogWarning(_("Unmatched '{' in an entry for mime type %s."),
170 params.GetMimeType().c_str());
171 str << wxT("%{");
172 }
173 else {
174 wxString param(pc + 1, pEnd - pc - 1);
175 str << wxT('\'') << params.GetParamValue(param) << wxT('\'');
176 pc = pEnd;
177 }
178 }
179 break;
180
181 case wxT('n'):
182 case wxT('F'):
183 // TODO %n is the number of parts, %F is an array containing
184 // the names of temp files these parts were written to
185 // and their mime types.
186 break;
187
188 default:
189 wxLogDebug(wxT("Unknown field %%%c in command '%s'."),
190 *pc, command.c_str());
191 str << *pc;
192 }
193 }
194 else {
195 str << *pc;
196 }
197 }
198
199 // metamail(1) man page states that if the mailcap entry doesn't have '%s'
200 // the program will accept the data on stdin so normally we should append
201 // "< %s" to the end of the command in such case, but not all commands
202 // behave like this, in particular a common test is 'test -n "$DISPLAY"'
203 // and appending "< %s" to this command makes the test fail... I don't
204 // know of the correct solution, try to guess what we have to do.
205
206 // test now carried out on reading file so test should never get here
207 if ( !hasFilename && !str.empty()
208 #ifdef __UNIX__
209 && !str.StartsWith(_T("test "))
210 #endif // Unix
211 ) {
212 str << wxT(" < '") << params.GetFileName() << wxT('\'');
213 }
214
215 return str;
216 }
217
218 wxFileType::wxFileType(const wxFileTypeInfo& info)
219 {
220 m_info = &info;
221 m_impl = NULL;
222 }
223
224 wxFileType::wxFileType()
225 {
226 m_info = NULL;
227 m_impl = new wxFileTypeImpl;
228 }
229
230 wxFileType::~wxFileType()
231 {
232 if ( m_impl )
233 delete m_impl;
234 }
235
236 bool wxFileType::GetExtensions(wxArrayString& extensions)
237 {
238 if ( m_info )
239 {
240 extensions = m_info->GetExtensions();
241 return true;
242 }
243
244 return m_impl->GetExtensions(extensions);
245 }
246
247 bool wxFileType::GetMimeType(wxString *mimeType) const
248 {
249 wxCHECK_MSG( mimeType, false, _T("invalid parameter in GetMimeType") );
250
251 if ( m_info )
252 {
253 *mimeType = m_info->GetMimeType();
254
255 return true;
256 }
257
258 return m_impl->GetMimeType(mimeType);
259 }
260
261 bool wxFileType::GetMimeTypes(wxArrayString& mimeTypes) const
262 {
263 if ( m_info )
264 {
265 mimeTypes.Clear();
266 mimeTypes.Add(m_info->GetMimeType());
267
268 return true;
269 }
270
271 return m_impl->GetMimeTypes(mimeTypes);
272 }
273
274 bool wxFileType::GetIcon(wxIconLocation *iconLoc) const
275 {
276 if ( m_info )
277 {
278 if ( iconLoc )
279 {
280 iconLoc->SetFileName(m_info->GetIconFile());
281 #ifdef __WXMSW__
282 iconLoc->SetIndex(m_info->GetIconIndex());
283 #endif // __WXMSW__
284 }
285
286 return true;
287 }
288
289 return m_impl->GetIcon(iconLoc);
290 }
291
292 bool
293 wxFileType::GetIcon(wxIconLocation *iconloc,
294 const MessageParameters& params) const
295 {
296 if ( !GetIcon(iconloc) )
297 {
298 return false;
299 }
300
301 // we may have "%s" in the icon location string, at least under Windows, so
302 // expand this
303 if ( iconloc )
304 {
305 iconloc->SetFileName(ExpandCommand(iconloc->GetFileName(), params));
306 }
307
308 return true;
309 }
310
311 bool wxFileType::GetDescription(wxString *desc) const
312 {
313 wxCHECK_MSG( desc, false, _T("invalid parameter in GetDescription") );
314
315 if ( m_info )
316 {
317 *desc = m_info->GetDescription();
318
319 return true;
320 }
321
322 return m_impl->GetDescription(desc);
323 }
324
325 bool
326 wxFileType::GetOpenCommand(wxString *openCmd,
327 const wxFileType::MessageParameters& params) const
328 {
329 wxCHECK_MSG( openCmd, false, _T("invalid parameter in GetOpenCommand") );
330
331 if ( m_info )
332 {
333 *openCmd = ExpandCommand(m_info->GetOpenCommand(), params);
334
335 return true;
336 }
337
338 return m_impl->GetOpenCommand(openCmd, params);
339 }
340
341 wxString wxFileType::GetOpenCommand(const wxString& filename) const
342 {
343 wxString cmd;
344 if ( !GetOpenCommand(&cmd, filename) )
345 {
346 // return empty string to indicate an error
347 cmd.clear();
348 }
349
350 return cmd;
351 }
352
353 bool
354 wxFileType::GetPrintCommand(wxString *printCmd,
355 const wxFileType::MessageParameters& params) const
356 {
357 wxCHECK_MSG( printCmd, false, _T("invalid parameter in GetPrintCommand") );
358
359 if ( m_info )
360 {
361 *printCmd = ExpandCommand(m_info->GetPrintCommand(), params);
362
363 return true;
364 }
365
366 return m_impl->GetPrintCommand(printCmd, params);
367 }
368
369
370 size_t wxFileType::GetAllCommands(wxArrayString *verbs,
371 wxArrayString *commands,
372 const wxFileType::MessageParameters& params) const
373 {
374 if ( verbs )
375 verbs->Clear();
376 if ( commands )
377 commands->Clear();
378
379 #if defined (__WXMSW__) || defined(__UNIX__)
380 return m_impl->GetAllCommands(verbs, commands, params);
381 #else // !__WXMSW__ || Unix
382 // we don't know how to retrieve all commands, so just try the 2 we know
383 // about
384 size_t count = 0;
385 wxString cmd;
386 if ( GetOpenCommand(&cmd, params) )
387 {
388 if ( verbs )
389 verbs->Add(_T("Open"));
390 if ( commands )
391 commands->Add(cmd);
392 count++;
393 }
394
395 if ( GetPrintCommand(&cmd, params) )
396 {
397 if ( verbs )
398 verbs->Add(_T("Print"));
399 if ( commands )
400 commands->Add(cmd);
401
402 count++;
403 }
404
405 return count;
406 #endif // __WXMSW__/| __UNIX__
407 }
408
409 bool wxFileType::Unassociate()
410 {
411 #if defined(__WXMSW__)
412 return m_impl->Unassociate();
413 #elif defined(__UNIX__)
414 return m_impl->Unassociate(this);
415 #else
416 wxFAIL_MSG( _T("not implemented") ); // TODO
417 return false;
418 #endif
419 }
420
421 bool wxFileType::SetCommand(const wxString& cmd,
422 const wxString& verb,
423 bool overwriteprompt)
424 {
425 #if defined (__WXMSW__) || defined(__UNIX__)
426 return m_impl->SetCommand(cmd, verb, overwriteprompt);
427 #else
428 wxUnusedVar(cmd);
429 wxUnusedVar(verb);
430 wxUnusedVar(overwriteprompt);
431 wxFAIL_MSG(_T("not implemented"));
432 return false;
433 #endif
434 }
435
436 bool wxFileType::SetDefaultIcon(const wxString& cmd, int index)
437 {
438 wxString sTmp = cmd;
439 #ifdef __WXMSW__
440 // VZ: should we do this?
441 // chris elliott : only makes sense in MS windows
442 if ( sTmp.empty() )
443 GetOpenCommand(&sTmp, wxFileType::MessageParameters(wxEmptyString, wxEmptyString));
444 #endif
445 wxCHECK_MSG( !sTmp.empty(), false, _T("need the icon file") );
446
447 #if defined (__WXMSW__) || defined(__UNIX__)
448 return m_impl->SetDefaultIcon (cmd, index);
449 #else
450 wxUnusedVar(index);
451 wxFAIL_MSG(_T("not implemented"));
452 return false;
453 #endif
454 }
455
456
457 // ----------------------------------------------------------------------------
458 // wxMimeTypesManager
459 // ----------------------------------------------------------------------------
460
461 void wxMimeTypesManager::EnsureImpl()
462 {
463 if ( !m_impl )
464 m_impl = new wxMimeTypesManagerImpl;
465 }
466
467 bool wxMimeTypesManager::IsOfType(const wxString& mimeType,
468 const wxString& wildcard)
469 {
470 wxASSERT_MSG( mimeType.Find(wxT('*')) == wxNOT_FOUND,
471 wxT("first MIME type can't contain wildcards") );
472
473 // all comparaisons are case insensitive (2nd arg of IsSameAs() is false)
474 if ( wildcard.BeforeFirst(wxT('/')).
475 IsSameAs(mimeType.BeforeFirst(wxT('/')), false) )
476 {
477 wxString strSubtype = wildcard.AfterFirst(wxT('/'));
478
479 if ( strSubtype == wxT("*") ||
480 strSubtype.IsSameAs(mimeType.AfterFirst(wxT('/')), false) )
481 {
482 // matches (either exactly or it's a wildcard)
483 return true;
484 }
485 }
486
487 return false;
488 }
489
490 wxMimeTypesManager::wxMimeTypesManager()
491 {
492 m_impl = NULL;
493 }
494
495 wxMimeTypesManager::~wxMimeTypesManager()
496 {
497 if ( m_impl )
498 delete m_impl;
499 }
500
501 bool wxMimeTypesManager::Unassociate(wxFileType *ft)
502 {
503 #if defined(__UNIX__) && !defined(__CYGWIN__) && !defined(__WINE__)
504 return m_impl->Unassociate(ft);
505 #else
506 return ft->Unassociate();
507 #endif
508 }
509
510
511 wxFileType *
512 wxMimeTypesManager::Associate(const wxFileTypeInfo& ftInfo)
513 {
514 EnsureImpl();
515
516 #if defined(__WXMSW__) || defined(__UNIX__)
517 return m_impl->Associate(ftInfo);
518 #else // other platforms
519 wxUnusedVar(ftInfo);
520 wxFAIL_MSG( _T("not implemented") ); // TODO
521 return NULL;
522 #endif // platforms
523 }
524
525 wxFileType *
526 wxMimeTypesManager::GetFileTypeFromExtension(const wxString& ext)
527 {
528 EnsureImpl();
529 wxFileType *ft = m_impl->GetFileTypeFromExtension(ext);
530
531 if ( !ft ) {
532 // check the fallbacks
533 //
534 // TODO linear search is potentially slow, perhaps we should use a
535 // sorted array?
536 size_t count = m_fallbacks.GetCount();
537 for ( size_t n = 0; n < count; n++ ) {
538 if ( m_fallbacks[n].GetExtensions().Index(ext) != wxNOT_FOUND ) {
539 ft = new wxFileType(m_fallbacks[n]);
540
541 break;
542 }
543 }
544 }
545
546 return ft;
547 }
548
549 wxFileType *
550 wxMimeTypesManager::GetFileTypeFromMimeType(const wxString& mimeType)
551 {
552 EnsureImpl();
553 wxFileType *ft = m_impl->GetFileTypeFromMimeType(mimeType);
554
555 if ( !ft ) {
556 // check the fallbacks
557 //
558 // TODO linear search is potentially slow, perhaps we should use a
559 // sorted array?
560 size_t count = m_fallbacks.GetCount();
561 for ( size_t n = 0; n < count; n++ ) {
562 if ( wxMimeTypesManager::IsOfType(mimeType,
563 m_fallbacks[n].GetMimeType()) ) {
564 ft = new wxFileType(m_fallbacks[n]);
565
566 break;
567 }
568 }
569 }
570
571 return ft;
572 }
573
574 bool wxMimeTypesManager::ReadMailcap(const wxString& filename, bool fallback)
575 {
576 EnsureImpl();
577 return m_impl->ReadMailcap(filename, fallback);
578 }
579
580 bool wxMimeTypesManager::ReadMimeTypes(const wxString& filename)
581 {
582 EnsureImpl();
583 return m_impl->ReadMimeTypes(filename);
584 }
585
586 void wxMimeTypesManager::AddFallbacks(const wxFileTypeInfo *filetypes)
587 {
588 EnsureImpl();
589 for ( const wxFileTypeInfo *ft = filetypes; ft && ft->IsValid(); ft++ ) {
590 AddFallback(*ft);
591 }
592 }
593
594 size_t wxMimeTypesManager::EnumAllFileTypes(wxArrayString& mimetypes)
595 {
596 EnsureImpl();
597 size_t countAll = m_impl->EnumAllFileTypes(mimetypes);
598
599 // add the fallback filetypes
600 size_t count = m_fallbacks.GetCount();
601 for ( size_t n = 0; n < count; n++ ) {
602 if ( mimetypes.Index(m_fallbacks[n].GetMimeType()) == wxNOT_FOUND ) {
603 mimetypes.Add(m_fallbacks[n].GetMimeType());
604 countAll++;
605 }
606 }
607
608 return countAll;
609 }
610
611 void wxMimeTypesManager::Initialize(int mcapStyle,
612 const wxString& sExtraDir)
613 {
614 #if defined(__UNIX__) && !defined(__CYGWIN__) && !defined(__WINE__)
615 EnsureImpl();
616
617 m_impl->Initialize(mcapStyle, sExtraDir);
618 #else
619 (void)mcapStyle;
620 (void)sExtraDir;
621 #endif // Unix
622 }
623
624 // and this function clears all the data from the manager
625 void wxMimeTypesManager::ClearData()
626 {
627 #if defined(__UNIX__) && !defined(__CYGWIN__) && !defined(__WINE__)
628 EnsureImpl();
629
630 m_impl->ClearData();
631 #endif // Unix
632 }
633
634 // ----------------------------------------------------------------------------
635 // global data and wxMimeTypeCmnModule
636 // ----------------------------------------------------------------------------
637
638 // private object
639 static wxMimeTypesManager gs_mimeTypesManager;
640
641 // and public pointer
642 wxMimeTypesManager *wxTheMimeTypesManager = &gs_mimeTypesManager;
643
644 class wxMimeTypeCmnModule: public wxModule
645 {
646 public:
647 wxMimeTypeCmnModule() : wxModule() { }
648 virtual bool OnInit() { return true; }
649 virtual void OnExit()
650 {
651 // this avoids false memory leak allerts:
652 if ( gs_mimeTypesManager.m_impl != NULL )
653 {
654 delete gs_mimeTypesManager.m_impl;
655 gs_mimeTypesManager.m_impl = NULL;
656 gs_mimeTypesManager.m_fallbacks.Clear();
657 }
658 }
659
660 DECLARE_DYNAMIC_CLASS(wxMimeTypeCmnModule)
661 };
662
663 IMPLEMENT_DYNAMIC_CLASS(wxMimeTypeCmnModule, wxModule)
664
665 #endif // wxUSE_MIMETYPE