"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1997 by eXept Software AG 

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libview2' }"

"{ NameSpace: Smalltalk }"

Object subclass:#MIMETypes

	instanceVariableNames:''

	classVariableNames:'CharSetToFontMapping DefaultCommandPerMIMEPerOS

		DefaultPrintCommandPerMIMEPerOS

		FileSuffixToImageReaderClassMapping FileSuffixToTypeMapping

		FilenameToTypeMapping LastSuffix LastType

		SuffixToCommentStringMapping SuffixToParenthesisSpecMapping

		TypeFromContentsDetectors TypeToCommentStringMapping

		TypeToFileSuffixMapping TypeToImageReaderClassMapping

		TypeToInfoMapping TypeToParenthesisSpecMapping

		TypeToViewerApplicationMapping'

	poolDictionaries:''

	category:'Net-Communication-Support'

!

ImmutableString variableByteSubclass:#MIMEType

	instanceVariableNames:''

	classVariableNames:'CachedTypes'

	poolDictionaries:''

	privateIn:MIMETypes

!

!MIMETypes class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1997 by eXept Software AG 

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    just a place to keep MIME information

    (avoid spreading things at many places)

    MIMETypes is abstract and functional.

    Actually, in some OperatingSystems, this information may

    be found in some config files (or registries).

    Therefore, this class may have to be extended to support this

    and fetch the information from there eventually.

    [author:]

        Claus Gittinger

"

!

examples

"

                                                                            [exBegin]

    MIMETypes mimeTypeFromString:'text/plain' 

                                                                            [exEnd]

                                                                            [exBegin]

    MIMETypes mimeTypeFromString:'application/x-expecco-testsuite' 

                                                                            [exEnd]

                                                                            [exBegin]

    MIMETypes mimeTypeForSuffix:'gif'     

    MIMETypes mimeTypeForSuffix:'ets'

    MIMETypes mimeTypeForSuffix:'xlsx'

                                                                            [exEnd]

"

!

knownTypes

"

    simply a reminder for me ...

    application         mime                            file extentsions

        powerpoint      application/ms-powerpoint       .pot, .ppz, .ppt, .pps, 

                        application/mspowerpoint        

                        application/vnd.ms-powerpoint   

                        application/x-mspowerpoint

        shockwave       application/x-shockwave-flash   .swf     

        futuresplash    application/futuresplash        .spl

"

! !

!MIMETypes class methodsFor:'initialization'!

addMimeTypeDetector:aMimeTypeFromContentsDetectorBlock

    "any class (especially: image readers) may add a block

     which detects the mime-type from a givel contents.

     The block is called with two arguments, some data (usually the first few kilobytes

     of a file) and the suffix of the file, or nil if unknown.

     The block should return the mimeType or nil."

    TypeFromContentsDetectors isNil ifTrue:[ TypeFromContentsDetectors := OrderedCollection new ]. 

    TypeFromContentsDetectors add:aMimeTypeFromContentsDetectorBlock.

!

initialize

    "initialize wellKnown facts"

    MIMEType initialize. "must be initialized first"

    LastSuffix := LastType := nil.

    self initializeFileNameToMimeTypeMapping.

    self initializeImageReaderMappings.

    self initializeCommentStringMappings.

    self initializeParenthesisSpecMappings.

    "

     self initialize

    "

    "Modified: / 10-04-2007 / 15:16:44 / cg"

    "Modified (comment): / 29-11-2011 / 19:11:51 / cg"

!

initializeCommentStringMappings

    "these are used by the editor's comment/uncomment functions"

    TypeToCommentStringMapping := Dictionary new.

    SuffixToCommentStringMapping := Dictionary new.

    TypeToCommentStringMapping 

        at:'application/x-make'

        put:#('#' (nil nil)).           "/ '#' EOL comments only

    TypeToCommentStringMapping 

        at:'application/x-sh'

        put:#('#' (nil nil)).           "/ '#' EOL comments only

    #('text/html' 'text/xml' 

      'application/xml' 

      'application/x-expecco-testsuite'

      'application/x-expecco-logfile'

    )

    do:[:eachXMLType |

        TypeToCommentStringMapping 

            at:eachXMLType

            put:#(nil ('<!!-- ' ' -->')). "/ '<!!-- ... -->' delimited comments only

    ].

    TypeToCommentStringMapping 

        at:'text/css'

        put:#('//' ('/*' '*/')).          

    TypeToCommentStringMapping 

        at:'application/x-batch-script'

        put:#('@REM ' '@rem ' 'REM ' 'rem ' (nil nil)).         "/ 'rem ' for EOL comments only

    "/ the following is ST/X specific

    TypeToCommentStringMapping 

        at:'application/x-smalltalk-source'

        put:#('"/' ('"' '"')).           "/ '"/ ' for EOL; ".." for delimited comments

    "/ this is for standard smalltalk

"/    TypeToCommentStringMapping 

"/        at:'application/x-smalltalk-source'

"/        put:#(nil ('"' '"')).            "/ ".." for delimited comments only

    TypeToCommentStringMapping 

        at:'application/x-pascal-source'

        put:#(nil ('{' '}')).           "/ '{'..'}' for delimited comments

    "/ this is ANSI-c

    TypeToCommentStringMapping 

        at:'application/x-c-source'

        put:#('//' ('/*' '*/')).          

    TypeToCommentStringMapping 

        at:'application/x-cpp-source'

        put:#('//' ('/*' '*/')).          

    TypeToCommentStringMapping 

        at:'application/x-csharp-source'

        put:#('//' ('/*' '*/')).          

    TypeToCommentStringMapping 

        at:'application/x-java-source'

        put:#('//' ('/*' '*/')).          

    TypeToCommentStringMapping 

        at:'application/x-javascript'

        put:#('//' ('/*' '*/')).          

    TypeToCommentStringMapping 

        at:'application/x-lisp-source'

        put:#(';' (nil nil)).           "/ ';' for EOL comments only

    TypeToCommentStringMapping 

        at:'application/x-python-source'

        put:#('#' (nil nil)).           "/ '#' for EOL comments only

    TypeToCommentStringMapping 

        at:'application/x-asn1-source'

        put:#('--' ('--' '--')).          

    "/ st/x support files

    SuffixToCommentStringMapping 

        at:'style'

        put:#(';' (nil nil)).          

    SuffixToCommentStringMapping 

        at:'rs'

        put:#(';' (nil nil)).

    "Modified: / 06-09-2011 / 10:46:27 / cg"

!

initializeDefaultCommands

    "these are used to select an application to be opened when a file of a particular

     type is double clicked in the browser.

     TODO: move this to OS"

    |unixCommands win32Commands unixPrintCommands win32PrintCommands listToTry|

    DefaultCommandPerMIMEPerOS := Dictionary new.

    DefaultCommandPerMIMEPerOS at:#unix  put:(unixCommands := Dictionary new).

    DefaultCommandPerMIMEPerOS at:#win32 put:(win32Commands := Dictionary new).

    unixCommands at:'application/x-tar-compressed' put:'tar tvf -'.

    OperatingSystem isMSWINDOWSlike ifFalse:[ |cmd|

        OperatingSystem isOSXlike ifTrue:[

            unixCommands at:'text/html' put:('open -a Safari "%1"').       

            unixCommands at:'application/pdf' put:('open -a Preview "%1"').       

        ] ifFalse:[

            listToTry := #('firefox' 'chrome' 'chromium' 'konqueror' 'opera').

            cmd := listToTry

                        detect:[:aCmd| (OperatingSystem pathOfCommand:aCmd) notEmptyOrNil ]

                        ifNone:nil.

            cmd notNil ifTrue:[

                unixCommands at:'text/html' put:(cmd, ' "%1"')       

            ].

            listToTry := #('acroread' 'okular' 'evince' 'kpdf' 'xpdf').

            cmd := listToTry

                        detect:[:aCmd| (OperatingSystem pathOfCommand:aCmd) notEmptyOrNil ]

                        ifNone:nil.

            cmd notNil ifTrue:[

                unixCommands at:'application/pdf' put:(cmd, ' "%1"')       

            ].

        ].

    ].

    DefaultPrintCommandPerMIMEPerOS := Dictionary new.

    DefaultPrintCommandPerMIMEPerOS at:#unix  put:(unixPrintCommands := Dictionary new).

    DefaultPrintCommandPerMIMEPerOS at:#win32 put:(win32PrintCommands := Dictionary new).

    "/ if you have a good (intelligent) spooler ;-)

    unixPrintCommands at:'application/pdf'         put:'lpr "%1"'.

    "/ if not, you may need more...

    "/ unixPrintCommands at:'application/pdf'         put:'pdfToPS %1 | lpr'.

    "

     self initializeDefaultCommands

    "

    "Modified: / 12-05-2004 / 11:43:23 / cg"

!

initializeFileInfoMappings

    "these are used by the file browser if a 'file' command is not present in the OS"

    TypeToInfoMapping := Dictionary new.

    TypeToInfoMapping at:'application/x-smalltalk-source' put:'Smalltalk source'.

    TypeToInfoMapping at:'text/html' put:'HTML document'.

    TypeToInfoMapping at:'text/xml' put:'XML document'.

    TypeToInfoMapping at:'application/xml' put:'XML document'.

    TypeToInfoMapping at:'application/x-c-source' put:'C source'.

    TypeToInfoMapping at:'application/x-c-header' put:'C header file'.

    TypeToInfoMapping at:'application/x-cpp-source' put:'C++ source'.

    TypeToInfoMapping at:'application/x-csharp-source' put:'C# source'.

    TypeToInfoMapping at:'application/x-java-source' put:'Java source'.

    TypeToInfoMapping at:'application/x-javascript' put:'Javascript source'.

    TypeToInfoMapping at:'application/x-lisp-source' put:'Lisp source'.

    TypeToInfoMapping at:'application/x-python-source' put:'Python source'.

    TypeToInfoMapping at:'application/x-make' put:'make rules'.

    TypeToInfoMapping at:'application/binary' put:'binary object file'.

    "

     self initializeFileInfoMappings

     'foo.H' asFilename mimeTypeFromName

     'foo.o' asFilename mimeTypeFromName

    "

!

initializeFileNameToMimeTypeMapping

    "initialize wellKnown facts"

    |types|

    FileSuffixToTypeMapping isNil ifTrue:[

        FileSuffixToTypeMapping := Dictionary new

    ].

    TypeToFileSuffixMapping isNil ifTrue:[

        TypeToFileSuffixMapping := Dictionary new

    ].

    FilenameToTypeMapping isNil ifTrue:[

        FilenameToTypeMapping := Dictionary new.

    ].

    types := OrderedCollection new.

    types addAll:self textTypeList.

    types addAll:self imageTypeList.

    types addAll:self videoTypeList.

    types addAll:self audioTypeList.

    types addAll:self applicationTypeList.

    types addAll:self osSpecificTypeList.

    types pairWiseDo:[:suff :typeString|

        |type|

        type := MIMEType fromString:typeString.

        suff isArray ifTrue:[

            suff do:[:s | FileSuffixToTypeMapping at:s put:type].

            TypeToFileSuffixMapping at:type put:suff first.

        ] ifFalse:[

            FileSuffixToTypeMapping at:suff put:type.

            TypeToFileSuffixMapping at:type put:suff.

        ].

    ].

    self miscFilenameList pairWiseDo:[:nm :typeString|

        |type|

        type := MIMEType fromString:typeString.

        nm isArray ifTrue:[

            nm do:[:s | FilenameToTypeMapping at:s put:type]

        ] ifFalse:[

            FilenameToTypeMapping at:nm put:type

        ]

    ].

    "

     self initializeFileNameToMimeTypeMapping

    "

!

initializeImageReaderMappings

    "these are used so select an image reader, based on a bitmap image's mime type"

    |rdr|

    FileSuffixToImageReaderClassMapping isNil ifTrue:[

        FileSuffixToImageReaderClassMapping := Dictionary new

    ].

    "MIME" TypeToImageReaderClassMapping isNil ifTrue:[

        TypeToImageReaderClassMapping := Dictionary new

    ].

    "/ setup mimeType to image reader class mapping ...

    TypeToImageReaderClassMapping at:'image/jpeg' put:JPEGReader.

    TypeToImageReaderClassMapping at:'image/gif'  put:GIFReader.

    TypeToImageReaderClassMapping at:'image/tiff' put:TIFFReader.

    TypeToImageReaderClassMapping at:'image/png'  put:PNGReader.

    TypeToImageReaderClassMapping at:'image/icns' put:MacOSXIconReader.

    "/ setup suffix to image reader class mapping ...

    FileSuffixToImageReaderClassMapping at:'jpg'  put:JPEGReader.

    FileSuffixToImageReaderClassMapping at:'jpeg' put:JPEGReader.

    FileSuffixToImageReaderClassMapping at:'gif'  put:GIFReader.

    FileSuffixToImageReaderClassMapping at:'tif'  put:TIFFReader.

    FileSuffixToImageReaderClassMapping at:'tiff' put:TIFFReader.

    FileSuffixToImageReaderClassMapping at:'png'  put:PNGReader.

    FileSuffixToImageReaderClassMapping at:'icns'  put:MacOSXIconReader.

    "/ some 'used-to-be-optional' readers

    (rdr := Smalltalk at:#WindowsIconReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/bmp'      put:rdr.

        TypeToImageReaderClassMapping       at:'image/x-MS-bmp' put:rdr.

        TypeToImageReaderClassMapping       at:'image/x-ms-bmp' put:rdr.

        TypeToImageReaderClassMapping       at:'image/x-MS-ico' put:rdr.

        TypeToImageReaderClassMapping       at:'image/x-ms-ico' put:rdr.

        FileSuffixToImageReaderClassMapping at:'bmp'            put:rdr.

        FileSuffixToImageReaderClassMapping at:'ico'            put:rdr.

    ].

    (rdr := Smalltalk at:#XBMReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-xbitmap' put:rdr.

        FileSuffixToImageReaderClassMapping at:'xbm'             put:rdr.

    ].

    (rdr := Smalltalk at:#XPMReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-xpixmap' put:rdr.

        FileSuffixToImageReaderClassMapping at:'pm'              put:rdr.

    ].

    (rdr := Smalltalk at:#PBMReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-portable-pixmap'  put:rdr.

        TypeToImageReaderClassMapping       at:'image/x-portable-bitmap'  put:rdr.

        TypeToImageReaderClassMapping       at:'image/x-portable-graymap' put:rdr.

        TypeToImageReaderClassMapping       at:'image/x-portable-anymap'  put:rdr.

        FileSuffixToImageReaderClassMapping at:'ppm'                      put:rdr.

        FileSuffixToImageReaderClassMapping at:'pbm'                      put:rdr.

        FileSuffixToImageReaderClassMapping at:'pgm'                      put:rdr.

        FileSuffixToImageReaderClassMapping at:'pnm'                      put:rdr.

    ].

    (rdr := Smalltalk at:#PCXReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-pcx' put:rdr.

        FileSuffixToImageReaderClassMapping at:'pcx'         put:rdr.

    ].

    (rdr := Smalltalk at:#TargaReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-targa' put:rdr.

        FileSuffixToImageReaderClassMapping at:'tga'           put:rdr.

    ].

    (rdr := Smalltalk at:#XWDReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-xwindowdump' put:rdr.

        TypeToImageReaderClassMapping       at:'image/x-windowdump'  put:rdr.

        FileSuffixToImageReaderClassMapping at:'xwd'                 put:rdr.

    ].

    (rdr := Smalltalk at:#BlitImageReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-blitimage' put:rdr.

        FileSuffixToImageReaderClassMapping at:'48x48x1'           put:rdr.

    ].

    (rdr := Smalltalk at:#IrisRGBReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-rgb' put:rdr.

        FileSuffixToImageReaderClassMapping at:'rgb'         put:rdr.

    ].

    (rdr := Smalltalk at:#SunRasterReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-sunraster' put:rdr.

        FileSuffixToImageReaderClassMapping at:'im8'               put:rdr.

        FileSuffixToImageReaderClassMapping at:'icon'              put:rdr.

    ].

    (rdr := Smalltalk at:#ST80FormReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-st80-form' put:rdr.

        FileSuffixToImageReaderClassMapping at:'form'              put:rdr.

    ].

    (rdr := Smalltalk at:#FaceReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-face' put:rdr.

        FileSuffixToImageReaderClassMapping at:'face'         put:rdr.

    ].

    (rdr := Smalltalk at:#PCDReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-photo-cd' put:rdr.

        FileSuffixToImageReaderClassMapping at:'pcd'              put:rdr.

    ].

    (rdr := Smalltalk at:#CMURasterReader) notNil ifTrue:[

        TypeToImageReaderClassMapping       at:'image/x-cmu-raster' put:rdr.

        FileSuffixToImageReaderClassMapping at:'ras'                put:rdr.

    ].

    "/ movie formats - experimental and not yet complete / finished / delivered / published

"/    (rdr := Smalltalk at:#FLIReader) notNil ifTrue:[

"/        TypeToImageReaderClassMapping       at:'video/x-fli' put:rdr.

"/        FileSuffixToImageReaderClassMapping at:'fli'         put:rdr.

"/    ].

"/    (rdr := Smalltalk at:#AVIReader) notNil ifTrue:[

"/        TypeToImageReaderClassMapping       at:'video/x-msvideo' put:rdr.

"/        FileSuffixToImageReaderClassMapping at:'avi'             put:rdr.

"/    ].

"/    (rdr := Smalltalk at:#AVIReader) notNil ifTrue:[

"/        TypeToImageReaderClassMapping       at:'video/x-msvideo' put:rdr.

"/        FileSuffixToImageReaderClassMapping at:'avi'             put:rdr.

"/    ].

"/    (rdr := Smalltalk at:#QuickTimeReader) notNil ifTrue:[

"/        TypeToImageReaderClassMapping       at:'video/quicktime' put:rdr.

"/        FileSuffixToImageReaderClassMapping at:'qt'              put:rdr.

"/        FileSuffixToImageReaderClassMapping at:'mov'             put:rdr.

"/        FileSuffixToImageReaderClassMapping at:'moov'            put:rdr.

"/    ].

"/    (rdr := Smalltalk at:#MPEG2Reader) notNil ifTrue:[

"/        TypeToImageReaderClassMapping       at:'video/x-mpeg2' put:rdr.

"/        FileSuffixToImageReaderClassMapping at:'mpg2'          put:rdr.

"/        FileSuffixToImageReaderClassMapping at:'mpv2'          put:rdr.

"/        FileSuffixToImageReaderClassMapping at:'mp2v'          put:rdr.

"/        FileSuffixToImageReaderClassMapping at:'mp2'           put:rdr.

"/    ].