hg/stx-libview: comparison Image.st

equal deleted inserted replaced

-:d4fb48e2c72d
+:c25149336a26
 documentation
 "
 this class provides (some time in the future) representation
 for all kinds of images (monochrome, greyscale and color)
 and will finally replace Form.
 For now (only ;-) depths of 1, 2, 4, 8, 16 and 24 are supported.
 An Image keeps all of its information in a device independent way,
 but may be associated to a device.
 The data held keeps all information which was originally present,
 even if the display-device has lower resolution.
 Therefore, it is possible to process and manipulate images without loosing
 color information.
 Images may be created manually (by providing a pixel array),
 by screen capture or by reading a file (using an ImageReader).
 This gives a device independent image.
 For display, a device representation is required, which can be
 aquired by sending the
 	'onDevice:aDevice'
 message to the image. This will create a (possibly dithered) device-form,
 representing the image using the currently available colors.
 In rare cases, an explicit monochrome representation of the image is needed
 (X servers take monochrome icons only), this can be created by sending
 it the message
 	'monochromeOn:aDevice'.
 Also, it is planned to generate another hi-color resolution version,
 which uses its own colormap and allows the use of all 256 colors on an 8bit display
 (this is not currently implemented).
 An images pixel interpretation is controlled by the photometric instance variable
 and (if that is #palette) a colorMap.
 This is in contrast to the ST-80 way, where all of this info is in the colorMap
 (and using specialized colorMaps for b&w / greyScale images).
 This may change in future versions for more application compatibility.
 To convert pictures from/to external file-formats, image readers are used
 which have the file-format knowledge built in.
 There are readers for most common formats available
 (see ImageReader and especially subclasses such as TIFFReader, GIFReader etc.).
 File formats are handled by subclasses of ImageReader, which understand
 a specific format. You can add more readers, by adding an association
 such as ('.jpg' -> JPEGReader) to the class variable 'FileFormats'
 (see the classes #initialize method, which sets up some default, and the
 patches/display.rc files, which add more).
 Some algorithms used here (especially dithering & color allocation) are
 experimental and far from being perfect (some are very slow).
 For now, the most common cases have been optimized and perform reasonably
 fast - however, with uncommon depth/visualType combinations, you may
 run into slower fallback methods ...
 Much more work is needed if you plan to do heavy image processing and will
 					    image was loaded - nil otherwise.
 					    Useful for image save functions
 					    and for the UIPainter utility.
 	imageSequence                       the imageSequence, of which the
 					    instance is a frame or nil,
 					    if its not part of a sequence.
 	bitsPerPixel                        not used in ST/X
 	depth                               - these have been added in instVar-slots
 	maxPixelValue                       - according to the ST-80's image class.
 					    Default is true.
 	ImageNotFoundQuerySignal
 			    <QuerySignal>   raised, if an image could not be loaded
 					    from a file. The parameter is the images
 					    fileName.
 					    A handler may return a replacement
 					    image or proceed with nil.
 					    If unhandled, a nil is returned from the
 					    image creation.
 	BadImageFormatQuerySignal
 			    <QuerySignal>   raised, if an image could not be loaded
 					    from a file due to a file error or
 					    unsupported format.
 					    A handler may return a replacement
 					    image or proceed with nil.
 					    If unhandled, a nil is returned from the
 					    image creation.
 a depth4 greyScale image:
 (default photometric is #blackIs0)
 									[exBegin]
 	(Depth4Image
 	     width:8
 	     height:4
 	     fromArray:#[
 			    16r00 16r11 16r22 16r33
 			    16r44 16r55 16r66 16r77
 			    16r88 16r99 16raa 16rbb
 			    16rcc 16rdd 16ree 16rff
 			]) inspect
 									[exEnd]
 the same, magnified:
 									[exBegin]
 	((Depth4Image
 	     width:4
 	     height:4
 	     fromArray:#[
 			    16r01 16r23
 			    16r45 16r67
 			    16r89 16rab
 			    16rcd 16ref
 			])
 	    magnifiedBy:30)
 		 inspect
 									[exEnd]
 the following has the same effect:
 									[exBegin]
 	((Image
 	     width:4
 	     height:4
 	     depth:4
 	     fromArray:#[
 			    16r01 16r23
 			    16r45 16r67
 			    16r89 16rab
 			    16rcd 16ref
 			])
 	    magnifiedBy:30)
 		 inspect
 									[exEnd]
 with reverse grey-interpretation:
 									[exBegin]
 	((Depth4Image
 	     width:4
 	     height:4
 	     fromArray:#[
 			    16r01 16r23
 			    16r45 16r67
 			    16r89 16rab
 			    16rcd 16ref
 			])
 	    photometric:#whiteIs0;
 	    magnifiedBy:30)
 		 inspect
 									[exEnd]
 with 1-bit-per-pixel rgb interpretation:
 									[exBegin]
 	((Depth4Image
 	     width:4
 	     height:4
 	     fromArray:#[
 			    16r01 16r23
 			    16r45 16r67
 			    16r89 16rab
 			    16rcd 16ref
 			])
 	    photometric:#rgb;
 	    samplesPerPixel:3;
 	    bitsPerSample:#(1 1 1);
 	    magnifiedBy:30)
 									[exEnd]
 with 1/2/1 rgb interpretation:
 									[exBegin]
 	((Depth4Image
 	     width:4
 	     height:4
 	     fromArray:#[
 			    16r01 16r23
 			    16r45 16r67
 			    16r89 16rab
 			    16rcd 16ref
 			])
 	    photometric:#rgb;
 	    samplesPerPixel:3;
 	    bitsPerSample:#(1 2 1);
 	    magnifiedBy:30)
 a 2plane greyscale image:
 									[exBegin]
 	((Depth2Image
 	     width:4
 	     height:4
 	     fromArray:#[
 			    4r0123
 			    4r1230
 			    4r2301
 			    4r3012
 			])
 	    magnifiedBy:30)
 		 inspect
 									[exEnd]
 with colors:
 									[exBegin]
 	((Depth2Image
 	     width:4
 	     height:4
 	     fromArray:#[
 			    4r0123
 			    4r1230
 			    4r2301
 			    4r3012
 			])
 	    colorMap:(Array with:(Color black)
 			    with:(Color red)
 			    with:(Color green)
 			    with:(Color blue));
 									[exEnd]
 depth8 image with 3/3/2 rgb interpretation:
 									[exBegin]
 	((Depth8Image
 	     width:16
 	     height:16
 	     fromArray:(ByteArray withAll:(0 to:16rFF)))
 	    photometric:#rgb;
 	    samplesPerPixel:3;
 	    bitsPerSample:#(3 3 2);
 									[exEnd]
 depth8 image with 2/2/2 rgb interpretation:
 									[exBegin]
 	((Depth8Image
 	     width:8
 	     height:8
 	     fromArray:(ByteArray withAll:(0 to:16r3F)))
 	    photometric:#rgb;
 	    samplesPerPixel:3;
 	    bitsPerSample:#(2 2 2);
 									[exEnd]
 trueColor image:
 									[exBegin]
 	((Depth24Image
 	     width:4
 	     height:4
 	     fromArray:#[
 		    16rFF 16r00 16r00  16rFF 16r00 16r00  16rFF 16r00 16r00  16rFF 16r00 16r00
 		    16r00 16rFF 16r00  16r00 16rFF 16r00  16r00 16rFF 16r00  16r00 16rFF 16r00
 		    16r00 16r00 16rFF  16r00 16r00 16rFF  16r00 16r00 16rFF  16r00 16r00 16rFF
 		    16rFF 16rFF 16rFF  16rFF 16rFF 16rFF  16rFF 16rFF 16rFF  16rFF 16rFF 16rFF
 			])
 	    photometric:#rgb;
 	    samplesPerPixel:3;
 	    bitsPerSample:#(8 8 8);
 	(Image fromFile:'myImage.tiff') inspect
 									[exEnd]
 magnifying (any factor):
 									[exBegin]
 	((Image fromFile:'goodies/bitmaps/gifImages/claus.gif')
 	    magnifiedTo:(48@48))
 		inspect
 									[exEnd]
 									[exBegin]
 	((Image fromFile:'goodies/bitmaps/gifImages/claus.gif')
 	    magnifiedBy:0.7)
 		inspect
 									[exEnd]
 rotating:
 									[exBegin]
 	((Image fromFile:'goodies/bitmaps/gifImages/claus.gif')
 	    rotated:90)
 		inspect
 									[exEnd]
 									[exBegin]
 	(((Image fromFile:'goodies/bitmaps/gifImages/claus.gif')
 	    magnifiedBy:0.3@0.7) rotated:270)
 		inspect
 									[exEnd]
 									[exBegin]
 	(((Image fromFile:'goodies/bitmaps/gifImages/claus.gif')
 	    ) rotated:30)
 		inspect
 									[exEnd]
 negative:
 									[exBegin]
 	((Image fromFile:'goodies/bitmaps/gifImages/claus.gif')
 	    negative)
 		inspect
 									[exEnd]
 "
 ! !
 "setup tracker of known pictures"
 Lobby isNil ifTrue:[
 	Lobby := Registry new.
 	ObjectMemory addDependent:self.
 	"/ define the algorithm to use for dithering -
 	"/ supported values are:
 	"/      #threshold
 	"/      #ordered
 	"/      #floydSteinberg
 	"/      #burkes
 	DitherAlgorithm := #floydSteinberg.
 	(Display notNil and:[Display hasGrayscales]) ifFalse:[
 	    NumberOfDitherColors := 64
 	] ifTrue:[
 	    "as far as I remember, this is about the number of grey values, the eye can distinguish"
 "initialize a default table to map from file extension to reader class.
 The mapping here is a default needed for proper operation of ST/X;
 see the 'smalltalk.rc'/'display.rc' startup files for a real (full) map."
 MIMETypes notNil ifTrue:[
-MIMETypes imageReaderForSuffix:'xbm'  put:XBMReader.
+	MIMETypes imageReaderForSuffix:'xbm'  put:XBMReader.
-MIMETypes imageReaderForSuffix:'tiff' put:TIFFReader.
+	MIMETypes imageReaderForSuffix:'tiff' put:TIFFReader.
-MIMETypes imageReaderForSuffix:'gif'  put:GIFReader.
+	MIMETypes imageReaderForSuffix:'gif'  put:GIFReader.
 ].
 "
 Image initializeFileFormatTable
 "
 "initialize a default table to map from mime type to reader class.
 The mapping here is a default needed for proper operation of ST/X;
 see the 'smalltalk.rc'/'display.rc' startup files for a real (full) map."
 MIMETypes notNil ifTrue:[
-MIMETypes mimeTypeForSuffix:'gif'       put:'image/gif'.
+	MIMETypes mimeTypeForSuffix:'gif'       put:'image/gif'.
-MIMETypes mimeTypeForSuffix:'tiff'      put:'image/tiff'.
+	MIMETypes mimeTypeForSuffix:'tiff'      put:'image/tiff'.
-MIMETypes mimeTypeForSuffix:'tif'       put:'image/tiff'.
+	MIMETypes mimeTypeForSuffix:'tif'       put:'image/tiff'.
-MIMETypes mimeTypeForSuffix:'xbm'       put:'image/x-xbitmap'.
+	MIMETypes mimeTypeForSuffix:'xbm'       put:'image/x-xbitmap'.
-MIMETypes mimeTypeForSuffix:'xpm'       put:'image/x-xpixmap'.
+	MIMETypes mimeTypeForSuffix:'xpm'       put:'image/x-xpixmap'.
 ].
 "
 Image initializeMIMETable
 "
 ! !
 !Image class methodsFor:'instance creation'!
 extent:ext
 "create a new image, given extent.
 Assume a depth of 1, unless an explicit imageClass is the receiver."
 ^ self width:(ext x) height:(ext y)
 "Created: / 30.9.1998 / 22:31:26 / cg"
 !
 extent:ext depth:d
 "ST-80 compatibility"
 ^ self width:ext x height:ext y depth:d
 !
 extent:ext depth:d bits:bits
 "ST-80 compatibility; assume 32-bit padding"
 fromImage:anImage photometric:photometricOrNil
 "create & return an Image given another image. This can be used to
 convert an image to another depth."
 (self == Image
 or:[anImage class == self
 	and:[photometricOrNil isNil or:[photometricOrNil == anImage photometric]]]) ifTrue:[^ anImage].
 ^ self new fromImage:anImage photometric:photometricOrNil.
 "
 |i1 i8|
 (Image fromSubForm:(5@5 corner:10@10) in:f) inspect
 "
 !
 fromSubImage:anImage in:aRectangle
 "create & return an Image from a rectangular area in another image.
 This can also be used to get a subimage in another depth."
 |cls newImage|
 self == Image ifTrue:[
-cls := (self implementorForDepth:anImage depth).
+	cls := (self implementorForDepth:anImage depth).
 ] ifFalse:[
-cls := self.
+	cls := self.
 ].
 newImage := cls new.
 ^ newImage fromSubImage:anImage in:aRectangle.
 "
 width:w height:h depth:d fromArray:pixelData
 "create a new image, given width, height, depth and data.
 Data must be a ByteArray containing correctly aligned bits for the specified
 depth (8-bit padded)."
 ^ (self newForDepth:d)
 	width:w height:h depth:d fromArray:pixelData
 "
 Image width:8
 	   height:8
 	   depth:1
 	   fromArray:#[2r11001100
 		       2r00110011
 		       2r11001100
 		       2r11001100
 		       2r00110011].
 "
 "
 Image width:8
 	   height:8
 	   depth:2
 	   fromArray:#[4r1100 4r1100
 		       4r0011 4r0011
 		       4r1100 4r1100
 		       4r0011 4r0011
 		       4r1100 4r1100
 		       4r1100 4r1100
 		       4r0011 4r0011].
 "
 "
 Image width:8
 	   height:8
 	   depth:4
 	   fromArray:#[16r00 16r01 16rf0 16rf1
 		       16r02 16r03 16rf2 16rf3
 		       16r04 16r05 16rf4 16rf5
 		       16r06 16r07 16rf6 16rf7
 		       16r08 16r09 16rf8 16rf9
 width:w height:h depth:d fromArray:pixelData pad:padding
 "create a new image, given width, height, depth and data.
 Data must be a ByteArray containing correctly aligned bits for the specified
 depth."
 |img newBits
 srcRowBytes "{ Class: SmallInteger }"
 dstRowBytes "{ Class: SmallInteger }"
 nextDstIndex "{ Class: SmallInteger }"
 srcIndex "{ Class: SmallInteger }"
 dstIndex "{ Class: SmallInteger }" |
 	srcIndex := 1.
 	dstIndex := 1.
 	1 to:h do:[:row |
 	    nextDstIndex := dstIndex + dstRowBytes.
 	    newBits replaceFrom:dstIndex
 			     to:(nextDstIndex - 1)
 			   with:pixelData
 		     startingAt:srcIndex.
 	    srcIndex := srcIndex + srcRowBytes.
 	    dstIndex := nextDstIndex.
 	pixels := anArray
 ].
 ^ cls new width:w height:h depth:d fromArray:pixels
 "
 Image width:8
 	   height:8
 	   fromArray:#[2r11001100
 		       2r00110011
 		       2r11001100
 		       2r00110011
 		       2r11001100
 "Created: 1.2.1997 / 14:40:29 / cg"
 ! !
 !Image class methodsFor:'cleanup'!
 releaseResourcesOnDevice:aDevice
 "this is sent when a display connection is closed,
 to release all cached Images from that device"
 Lobby
-unregisterAllForWhich:[:eachImage |
+	unregisterAllForWhich:[:eachImage |
-|ok|
+	    |ok|
-ok := eachImage graphicsDevice == aDevice.
+	    ok := eachImage graphicsDevice == aDevice.
-ok ifTrue:[
+	    ok ifTrue:[
-eachImage releaseFromDevice
+		eachImage releaseFromDevice
-].
+	    ].
-ok
+	    ok
-]
+	]
 "Created: 16.1.1997 / 19:30:44 / cg"
 "Modified: 16.1.1997 / 19:33:49 / cg"
 ! !
 separate directory, thereby overriding system bitmaps easily.
 If the file is unreadable or does not contain an appropriate image,
 the ImageNotFoundQuerySignal is raised, which may be handled to
 proceed with some replacement image. If unhandled, nil is returned."
 |image name fn nm inStream suffix readerClass
 mustDecompress inPipe readersErrorMsg|
 "before trying each reader, check if the file is readable"
 name := aFileName asFilename.
 inStream := Smalltalk systemFileStreamFor:name.
 inStream isNil ifTrue:[
-inStream := Smalltalk bitmapFileStreamFor:name.
+	inStream := Smalltalk bitmapFileStreamFor:name.
-inStream isNil ifTrue:[
+	inStream isNil ifTrue:[
-"this signal is a query - if noone seems to care, return nil.
+	    "this signal is a query - if noone seems to care, return nil.
-However, a handler may provide a replacement image."
+	     However, a handler may provide a replacement image."
-^ ImageNotFoundQuerySignal
+	    ^ ImageNotFoundQuerySignal
-raiseRequestWith:aFileName
+			raiseRequestWith:aFileName
-errorString:('IMAGE [warning]: ''' , name pathName, ''' does not exist or is not readable').
+			errorString:('IMAGE [warning]: ''' , name pathName, ''' does not exist or is not readable').
-].
+	].
 ].
 fn := inStream pathName asFilename.
 inStream close.
 nm := fn name.
 suffix := fn suffix.
 "handle compressed-suffix"
 (#('Z' 'gz') includes:suffix) ifTrue:[
-fn := fn withoutSuffix.
+	fn := fn withoutSuffix.
-nm := fn name.
+	nm := fn name.
-suffix := fn suffix.
+	suffix := fn suffix.
-mustDecompress := true.
+	mustDecompress := true.
 ].
 suffix isEmpty ifTrue:[
-suffix := nm.
+	suffix := nm.
 ].
 "get the imageReader class from the files extension and ask it first"
 readerClass := MIMETypes imageReaderForSuffix:suffix.
 readerClass notNil ifTrue:[
-mustDecompress == true ifTrue:[
+	mustDecompress == true ifTrue:[
-inPipe := PipeStream readingFrom:'gunzip <' , fn pathName.
+	    inPipe := PipeStream readingFrom:'gunzip <' , fn pathName.
-inPipe notNil ifTrue:[
+	    inPipe notNil ifTrue:[
-[
+		[
-image := readerClass fromStream:inPipe.
+		    image := readerClass fromStream:inPipe.
-] ensure:[
+		] ensure:[
-inPipe close
+		    inPipe close
-].
+		].
-]
+	    ]
-] ifFalse:[
+	] ifFalse:[
-BadImageFormatQuerySignal handle:[:ex |
+	    BadImageFormatQuerySignal handle:[:ex |
-Transcript showCR:(readersErrorMsg := ex description).
+		Transcript showCR:(readersErrorMsg := ex description).
-image := nil.
+		image := nil.
-ex return.
+		ex return.
-] do:[
+	    ] do:[
-image := readerClass fromFile:fn.
+		image := readerClass fromFile:fn.
-].
+	    ].
-].
+	].
-image notNil ifTrue:[^ image].
+	image notNil ifTrue:[^ image].
 ].
 (readerClass isNil or:[readersErrorMsg notNil]) ifTrue:[
-"no known extension (or wrong extension)
+	"no known extension (or wrong extension)
-- ask all readers if they know this format ...
+	 - ask all readers if they know this format ...
-... these look into the file, and investigate the header.
+	 ... these look into the file, and investigate the header.
-therefore, it takes a bit longer."
+	 therefore, it takes a bit longer."
-MIMETypes imageReaderClasses do:[:mimeReaderClass |
+	MIMETypes imageReaderClasses do:[:mimeReaderClass |
-(mimeReaderClass notNil
+	    (mimeReaderClass notNil
-and:[mimeReaderClass ~~ readerClass]) ifTrue:[
+	    and:[mimeReaderClass ~~ readerClass]) ifTrue:[
-(mimeReaderClass isValidImageFile:name) ifTrue:[
+	       (mimeReaderClass isValidImageFile:name) ifTrue:[
-image := mimeReaderClass fromFile:name.
+		    image := mimeReaderClass fromFile:name.
-image notNil ifTrue:[
+		    image notNil ifTrue:[
-^ image
+			^ image
-]
+		    ]
-]
+		]
-]
+	    ]
-].
+	].
 ].
 "nope - unknown format
 this signal is a query - if noone seems to care, return nil.
 However, a handler may provide a replacement image."
 ^ BadImageFormatQuerySignal
-raiseRequestWith:aFileName
+	raiseRequestWith:aFileName
-errorString:(readersErrorMsg ? ('IMAGE [warning]: unknown image file format: ''' , aFileName asFilename pathName , '''')).
+	errorString:(readersErrorMsg ? ('IMAGE [warning]: unknown image file format: ''' , aFileName asFilename pathName , '''')).
 "
 Image fromFile:'goodies/bitmaps/gifImages/claus.gif'
 Image fromFile:'goodies/bitmaps/gifImages/garfield.gif'
 Image fromFile:'fooBar'
 "
 "giving a message for non-existing images:
 Image imageNotFoundQuerySignal
 handle:[:ex |
-Transcript showCR:ex description.
+	Transcript showCR:ex description.
-ex proceedWith:nil
+	ex proceedWith:nil
 ] do:[
-Image fromFile:'fooBar'
+	 Image fromFile:'fooBar'
 ]
 "
 "giving a replacement for non-existing images:
 Image imageNotFoundQuerySignal
 answer:(Image fromFile:'libtool/bitmaps/SmalltalkX.xbm')
 do:[
-Image fromFile:'fooBar'
+	 Image fromFile:'fooBar'
 ]
 "
 "Modified: / 18.5.1999 / 15:48:20 / cg"
 !
 "
 !
 fromFile:aFileName on:aDevice
 "read an image from a file and prepare a device representation.
 Return nil (or whatever a handler returned),
 if the file is unreadable or does not contain an appropriate image."
 |img|
 img := self fromFile:aFileName.
 !
 fromFile:aFileName resolution:res
 "read an image from a file and (if required) scale the image
 as appropriate (only req'd for very high resolution displays).
 Return nil (or whatever a handler returned),
 if the file is unreadable or does not contain an appropriate image."
 ^ self fromFile:aFileName resolution:res on:nil
 "Created: 19.12.1996 / 14:02:13 / cg"
 fromFile:aFileName resolution:dpi on:aDevice
 "read an image from a file and (if required) scale the image
 as appropriate (only req'd with very high resolution displays).
 Prepare a device representation.
 Return nil (or whatever a handler returned),
 if the file is unreadable or does not contain an appropriate image."
 |img dev dpiH mag|
 img := self fromFile:aFileName.
 fromStream:aStream
 "read an image from a stream - this methods tries to find
 out the file format itself (by contents)
 and lets the appropriate reader read the file.
 To do this, the stream must be positionable.
 Return nil (or whatever a handler returned),
 if the stream does not contain an appropriate image."
 |image|
 "
 ask all readers if they know
 this format ...
 "
 MIMETypes imageReaderClasses do:[:readerClass |
-readerClass notNil ifTrue:[
+	readerClass notNil ifTrue:[
-image := readerClass fromStream:aStream.
+	    image := readerClass fromStream:aStream.
-image notNil ifTrue:[^ image].
+	    image notNil ifTrue:[^ image].
-]
+	]
 ].
 "
 nope - unknown format
 "
 "/    'Image [info]: unknown image file format in stream: ' infoPrintCR.
 ^ ImageNotFoundQuerySignal
-raiseRequestWith:aStream
+		raiseRequestWith:aStream
-errorString:('IMAGE [warning]: unknown image file format in stream').
+		errorString:('IMAGE [warning]: unknown image file format in stream').
 "
 Image fromFile:'goodies/bitmaps/gifImages/claus.gif'
 Image fromFile:'goodies/bitmaps/gifImages/garfield.gif'
 fromStream:aStream using:aReaderClass
 "read an image from a stream, given an imageReaderClass.
 Use this, if you know the files format, but it has an invalid
 extension (or non-definite header), so #fromStream: could not
 find out the images format.
 Return nil (or whatever a handler returned),
 if the stream does not contain an appropriate image."
 |image|
 image := aReaderClass fromStream:aStream.
 ! !
 !Image class methodsFor:'misc'!
 ditherAlgorithm
 "return the way we dither -
 	#threshold, or nil        -> no dither
 	#pattern, or #ordered     -> orderedDither (ugly, but fast)
 	#error or #floydSteinberg -> errorDiffusion; much better
 	#burkes                   -> errorDiffusion; even better."
 "Created: 17.6.1996 / 18:57:47 / cg"
 !
 ditherAlgorithm:aSymbol
 "define how to dither -
 	#threshold, or nil        -> no dither
 	#pattern, or #ordered     -> orderedDither (ugly, but fast)
 	#error or #floydSteinberg -> errorDiffusion; much better
 	#burkes                   -> errorDiffusion; even better."
 !
 orderedDitherMatrixOfSize:sz
 sz == 2 ifTrue:[
 	^ #[
 		0 2
 		3 1
 	   ].
 ].
 sz == 4 ifTrue:[
 sz == 8 ifTrue:[
 	^  #[
 		0 32  8 40    2 34 10 42
 	       48 16 56 24   50 18 58 26
 	       12 44  4 36   14 46  6 38
 	       60 28 52 20   62 30 54 22
 		3 35 11 43    1 33  9 41
 	       51 19 59 27   49 17 57 25
 	       15 47  7 39   13 45  5 37
 	       63 31 55 23   61 29 53 21
 	    ].
 ].
 ^ nil
 return it; return nil if unknown"
 ^ MIMETypes mimeTypeForSuffix:suffix
 "
 Image mimeTypeFromSuffix:'gif'
 Image mimeTypeFromSuffix:'tiff'
 Image mimeTypeFromSuffix:'foobar'
 "
 "Modified: 1.7.1997 / 00:17:27 / cg"
 ! !
 	      (use #fromScreen:on:grab: with a false grabArg then)."
 |display|
 display := Screen current.
 ^ self
 	fromScreen:(0@0 corner:(display width @ display height))
 	on:display
 	grab:true
 "
 "return an image of a part of the screen.
 WARNING: this temporarily grabs the display
 	      it may not work from within a buttonMotion
 	      (use #fromScreen:on:grab: with a false grabArg then)."
 ^ self
 	fromScreen:aRectangle
 	on:Screen current
 	grab:true
 "
 Image fromScreen:(0@0 corner:100@100)
 WARNING: this temporarily grabs the display
 	      it may not work from within a buttonMotion
 	      (use #fromScreen:on:grab: with a false grabArg then)."
 ^ self
 	fromScreen:aRectangle
 	on:aDevice
 	grab:true
 "
 Image fromScreen:(0@0 corner:100@100)
 "
 "return an image of a part of the screen, which may be on
 another Display. If the doGrab argument is true, the display
 is grabbed (i.e. blocked for others) and a camera cursor is
 shown while the readout is done.
 WARNING: with doGrab true, this temporarily grabs the display
-and it may not work from within a buttonMotion
+	      and it may not work from within a buttonMotion
-(use with a false grabArg then)."
+	      (use with a false grabArg then)."
 |depth vis img|
 depth := aDisplay depth.
 "/ (must do this for depth15 & depth16 displays, since
 "/  Depth16Image has no way to specify r/g/b masks ...)
 "/
 vis := aDisplay visualType.
 (vis == #TrueColor or:[vis == #DirectColor]) ifTrue:[
-depth > 8 ifTrue:[
+	depth > 8 ifTrue:[
-depth := 24.
+	    depth := 24.
-]
+	]
 ].
 img := self newForDepth:depth.
 ^ img fromScreen:aRectangle on:aDisplay grab:doGrab
 "Modified: / 26.1.1998 / 22:23:08 / cg"
 !
 fromScreenArea
 "return an image of a part of the screen;
 let user specify screen area.
 This is the same as #fromUser - kept for backward compatibility.
 Use #fromUser for ST-80 compatibility.
 WARNING: this temporarily grabs the display
 	      it may not work from within a buttonMotion
 !
 fromView:aView
 "return an image taken from a views contents as currently
 on the screen. The returned image has the same depth and photometric
 as the Display.
 Notice, that for invisible or partial covered views,
 the returned Image is NOT correct.
 You may want to raise the view before using this method.
 WARNING: this temporarily grabs the display
 	      it may not work from within a buttonMotion
 	      (use #fromView:grab: with a false grabArg then)."
 ^ self
 	fromView:aView
 	grab:true
 "
 Image fromView:(Launcher allInstances first window topView)
 Image fromView:(BrowserView allInstances first topView)
 "return an image taken from a views contents as currently
 on the screen. If the doGrab argument is true, the display
 is grabbed (i.e. blocked for others) and a camera cursor is
 shown while the readout is done.
 The returned image has the same depth and photometric
 as the Display.
 Notice, that for invisible or partial covered views,
 the returned Image is NOT correct.
 You may want to raise the view before using this method.
 WARNING: with doGrab true, this temporarily grabs the display
-and it may not work from within a buttonMotion
+	      and it may not work from within a buttonMotion
-(use with a false grabArg then)."
+	      (use with a false grabArg then)."
 ^ self fromView:aView grab:doGrab withDecoration:false
 "Created: / 26.3.1997 / 10:34:20 / cg"
 "Modified: / 10.10.2001 / 14:13:29 / cg"
 !
 fromView:aView grab:doGrab withDecoration:withDecoration
 "return an image taken from a views contents as currently
 on the screen, optionally with decoration included.
 If the doGrab argument is true, the display
 is grabbed (i.e. blocked for others) and a camera cursor is
 shown while the readout is done.
 The returned image has the same depth and photometric
 as the Display.
 Notice, that for invisible or partial covered views,
 the returned Image is NOT correct.
 You may want to raise the view before using this method.
 WARNING: with doGrab true, this temporarily grabs the display
-and it may not work from within a buttonMotion
+	      and it may not work from within a buttonMotion
-(use with a false grabArg then)."
+	      (use with a false grabArg then)."
 |org ext device cH bW bH|
 device := aView graphicsDevice.
 org := device translatePoint:(0@0) fromView:aView toView:nil.
 ext := aView extent.
 withDecoration ifTrue:[
-device platformName = 'WIN32' ifTrue:[
+	device platformName = 'WIN32' ifTrue:[
-cH := device captionHeight.
+	    cH := device captionHeight.
-bW := (device getSystemMetrics: #SM_CXFRAME )
+	    bW := (device getSystemMetrics: #SM_CXFRAME )
-"+ ( device getSystemMetrics: #borderFrameWidth )".
+		  "+ ( device getSystemMetrics: #borderFrameWidth )".
-bH := (device getSystemMetrics: #SM_CYFRAME )
+	    bH := (device getSystemMetrics: #SM_CYFRAME )
-" + ( device getSystemMetrics: #borderFrameHeight )".
+		  " + ( device getSystemMetrics: #borderFrameHeight )".
-org := org - (bW @ (bH + cH)).
+	    org := org - (bW @ (bH + cH)).
-ext := ext + ((bW + bW) @ (bH+bH+cH)).
+	    ext := ext + ((bW + bW) @ (bH+bH+cH)).
-].
+	].
 ].
 ^ self fromScreen:(org extent:ext) on:device grab:doGrab
 "
 Transcript topView raise. (Image fromView:Transcript topView grab:false withDecoration:false) inspect
 Transcript topView raise. (Image fromView:Transcript topView grab:false withDecoration:true) inspect
 "
 "Created: / 26-03-1997 / 10:34:20 / cg"
 "Modified: / 08-09-2006 / 15:41:41 / cg"
 ! !
 "
 |img|
 img := Image extent:100@100 depth:24.
 img photometric:#rgb.
 img data:(ByteArray new:100*100*3).
 img fillWhite:(0@0 corner:100@100).
 img fillBlack:(10@10 corner:90@90).
 img inspect.
 "
 !
 !Image methodsFor:'Compatibility-VW'!
 asCachedImage
 "return the receiver associated to the current screens device.
 For ST-80 compatibility
 (ST/X uses Image for both device- and nonDevice-images)"
 ^ self onDevice:Screen current
 "Modified: 23.4.1996 / 11:10:32 / cg"
 !
 asRetainedMedium
 "return the receiver associated to the current screens device.
 For ST-80 compatibility
 (ST/X uses Image for both device- and nonDevice-images)"
 ^ self onDevice:Screen current
 "Modified: 23.4.1996 / 11:10:32 / cg"
 tile:bounds from:origin in:tile rule:rule
 |orgX orgY tW tH|
 origin ~= (0@0) ifTrue:[
-self halt:'unimplemented'.
+	self halt:'unimplemented'.
 ].
 bounds ~= self bounds ifTrue:[
-self halt:'unimplemented'.
+	self halt:'unimplemented'.
 ].
 rule ~= #over ifTrue:[
-self halt:'unimplemented'.
+	self halt:'unimplemented'.
 ].
 orgX := origin x.
 orgY := origin y.
 tW := tile width.
 tH := tile height.
 (bounds top) to:(bounds bottom) by:tH do:[:dstY |
-(bounds left) to:(bounds right) by:(tile width) do:[:dstX |
+	(bounds left) to:(bounds right) by:(tile width) do:[:dstX |
-self
+	    self
-copyFrom:tile
+		copyFrom:tile
-x:orgX y:orgY
+		x:orgX y:orgY
-toX:dstX y:dstY
+		toX:dstX y:dstY
-width:tW height:tH.
+		width:tW height:tH.
-].
+	].
 ].
 !
 valueAtPoint:aPoint put:aColorValue
 aColorValue isInteger ifFalse:[
-self colorAtX:aPoint x y:aPoint y put:aColorValue
+	self colorAtX:aPoint x y:aPoint y put:aColorValue
 ] ifTrue:[
-self pixelAtX:aPoint x y:aPoint y put:aColorValue
+	self pixelAtX:aPoint x y:aPoint y put:aColorValue
 ]
 ! !
 !Image methodsFor:'accessing'!
 monoDeviceForm isNil ifTrue:[^ nil].
 ^ monoDeviceForm id
 !
 palette
 "return the colormap; ST-80 compatibility"
 ^ colorMap
 !
 palette:aColormap
 "set the colormap; ST-80 compatibility"
 self colorMap:aColormap
 "Created: 1.2.1996 / 15:09:25 / cg"
 ! !
 !Image methodsFor:'accessing-pixels'!
 at:aPoint
 "WARNING: for now, this returns a pixels color
 (backward compatibility with ST/X)
 In the future, this will return a pixel value (ST-80 compatibility)
 Use #colorAt: - for future compatibility.
 retrieve the pixel at aPoint; return a color.
 "Modified: / 21.6.1997 / 13:10:17 / cg"
 "Modified: / 9.1.1998 / 20:33:52 / stefan"
 !
 at:aPoint put:aColor
 "WARNING: for now, this expects a pixels color
 (backward compatibility with ST/X)
 In the future, this will expect a pixel value (ST-80 compatibility)
 Use #colorAt:put: - for future compatibility.
 set the pixel at aPoint to aColor.
 otherwise to 1. Nil is treated like noColor.
 (used by the bitmap editor)"
 |maskVal|
 (aColorOrPixelOrNil notNil and:[aColorOrPixelOrNil ~= Color noColor]) ifTrue:[
 	maskVal := 1.
 	aColorOrPixelOrNil isInteger ifTrue:[
 	    self pixelAt:aPoint put:aColorOrPixelOrNil.
 	] ifFalse:[
 	    self colorAt:aPoint put:aColorOrPixelOrNil
 	maskVal := 0.
 	self pixelAt:aPoint put:0.
 ].
 mask notNil ifTrue:[
 	mask pixelAt:aPoint put:maskVal
 ].
 "Modified: / 30.9.1998 / 22:42:44 / cg"
 !
 atImageAndMask:aPoint putValue:aPixelValueOrNil
 otherwise to 1.
 (used by the bitmap editor)"
 |pixVal maskVal|
 aPixelValueOrNil notNil ifTrue:[
 	pixVal := aPixelValueOrNil.
 	maskVal := 1.
 ] ifFalse:[
 	pixVal := 0.
 	maskVal := 0.
 ].
 mask notNil ifTrue:[
 	mask pixelAt:aPoint put:maskVal
 ].
 self pixelAt:aPoint put:pixVal
 "Modified: / 30.9.1998 / 22:42:44 / cg"
 !
 "Modified: 24.4.1997 / 17:17:59 / cg"
 !
 atX:x y:y
 "WARNING: for now, this returns a pixels color
 (backward compatibility with ST/X)
 In the future, this will return a pixel value (ST-80 compatibility)
 Use #colorAt: - for future compatibility.
 Retrieve a pixel at x/y; return a color.
 "Modified: 21.6.1997 / 13:10:32 / cg"
 !
 atX:x y:y put:aColor
 "WARNING: for now, this expects a pixels color
 (backward compatibility with ST/X)
 In the future, this will expect a pixel value (ST-80 compatibility)
 Use #colorAt:put: - for future compatibility.
 set the pixel at x/y to aColor.
 (i.e. if the receiver is a palette image, the color must be present in there).
 You should not use this method for image-processing, it is very slow ...
 (it is meant to access individual pixels - for example, in a bitmap editor)"
 aColor isInteger ifTrue:[
-'Image [warning]: the Image>>atX:y:put: will change semantics soon; use #colorAtX:y:put:' infoPrintCR.
+	'Image [warning]: the Image>>atX:y:put: will change semantics soon; use #colorAtX:y:put:' infoPrintCR.
-^ self pixelAtX:x y:y put:aColor
+	^ self pixelAtX:x y:y put:aColor
 ].
 ^ self colorAtX:x y:y put:aColor
 "Modified: 21.6.1997 / 13:10:44 / cg"
 !
 !
 bits
 "return the raw image data; depending on the photometric,
 this has to be interpreted as monochrome, greyscale,
 palette or rgb data.
 It is also packed to be dense, so a 4 bitPerSample palette image
 will store 2 pixels per byte, whereas a 2-bitPerPixel image will store
 4 pixels per byte."
 ^ bytes
 !
 Pixels start at 0/0 for upper left pixel, and end at
 width-1@height-1 for lower right pixel.
 The returned numbers interpretation depends on the photometric
 and the colormap. (see also Image>>at: and Image>>atX:y:)
 You should not use this method for image-processing of
 big images, its very slow ...
 (it is meant to access individual pixels - for example, in a bitmap editor)"
 ^ self subclassResponsibility
 "Created: 24.4.1997 / 16:06:56 / cg"
 "Modified: 24.4.1997 / 17:05:57 / cg"
 !
 valueAt:aPoint
 "WARNING: for now, this returns a pixels value
 (backward compatibility with ST/X)
 In the future, this will return a color (ST-80 compatibility)
 Use #pixelAt: - for future compatibility.
 Retrieve the pixelValue at aPoint; return an integer number.
 "Modified: 21.6.1997 / 13:11:19 / cg"
 !
 valueAtX:x y:y
 "WARNING: for now, this returns a pixels value
 (backward compatibility with ST/X)
 In the future, this will return a color (ST-80 compatibility)
 Use #pixelAt: - for future compatibility.
 Retrieve the pixelValue at aPoint; return an integer number.
 Pixels start at 0/0 for upper left pixel, and end at
 width-1@height-1 for lower right pixel.
 The returned numbers interpretation depends on the photometric
 and the colormap. (see also Image>>at: and Image>>atX:y:)
 You should not use this method for image-processing of
 big images, its very slow ...
 (it is meant to access individual pixels - for example, in a bitmap editor)"
 'Image [warning]: the Image>>valueAtX:y: will change semantics soon; use #pixelAtX:y' infoPrintCR.
 ^ self pixelAtX:x y:y
 "Modified: 23.4.1996 / 11:08:28 / cg"
 !
 bitsPerSample:aCollection
 "set the number of bits per sample.
 This interface is only to be used when initializing
 instances or by image readers. Calling for a change of an
 existing image may confuse later pixel interpretation."
 existing image may confuse later pixel interpretation."
 depth := self depth.
 bitsPerPixel := d.
 d == 24 ifTrue:[
-samplesPerPixel := 3.
+	samplesPerPixel := 3.
-bitsPerSample := #[8 8 8]
+	bitsPerSample := #[8 8 8]
 ] ifFalse:[
-samplesPerPixel := 1.
+	samplesPerPixel := 1.
-bitsPerSample := ByteArray with:d
+	bitsPerSample := ByteArray with:d
 ]
 "Modified: 20.2.1997 / 14:39:10 / cg"
 !
 !
 photometric:aSymbol
 "set the photometric interpretation of the pixel values.
 The argument, aSymbol is one of:
-#blackIs0, #whiteIs0, #palette, #rgb
+	#blackIs0, #whiteIs0, #palette, #rgb
 See TIFF documentation, from which the photometric concept is borrowed.
 This interface is only to be used when initializing
 instances or by image readers. Calling for a change of an
 existing image may confuse later pixel interpretation."
 |b|
 photometric := aSymbol.
 bitsPerSample isNil ifTrue:[
-photometric == #rgb ifTrue:[
+	photometric == #rgb ifTrue:[
-b := self class imageDepth // 3.
+	    b := self class imageDepth // 3.
-bitsPerSample := ByteArray with:b with:b with:b
+	    bitsPerSample := ByteArray with:b with:b with:b
-] ifFalse:[
+	] ifFalse:[
-bitsPerSample := ByteArray with:(self class imageDepth)
+	    bitsPerSample := ByteArray with:(self class imageDepth)
-].
+	].
 ].
 samplesPerPixel isNil ifTrue:[
-photometric == #rgb ifTrue:[
+	photometric == #rgb ifTrue:[
-samplesPerPixel := 3
+	    samplesPerPixel := 3
-] ifFalse:[
+	] ifFalse:[
-samplesPerPixel := 1
+	    samplesPerPixel := 1
-]
+	]
 ].
 "Modified: 10.6.1996 / 18:21:29 / cg"
 !
 width := aNumber
 "Modified: 23.4.1996 / 11:08:48 / cg"
 !
 width:w height:h
 "set the width and height of the image.
 This interface is only to be used when initializing
 instances or by image readers. Calling for a change of an
 existing image may confuse later pixel interpretation."
 This interface is only to be used when initializing
 instances or by image readers. Calling for a change of an
 existing image may confuse later pixel interpretation."
 ^ self
 	width:w
 	height:h
 	photometric:p
 	samplesPerPixel:spp
 	bitsPerSample:bps
 	colorMap:cm
 	bits:pixels
 	mask:nil
 "Modified: 20.6.1996 / 17:10:24 / cg"
 !
 "
 |i|
 i := Depth4Image
-width:4
+	     width:4
-height:4
+	     height:4
-fromArray:#[
+	     fromArray:#[
-16r01 16r23
+			    16r01 16r23
-16r45 16r67
+			    16r45 16r67
-16r89 16rab
+			    16r89 16rab
-16rcd 16ref
+			    16rcd 16ref
-].
+			].
 i := i magnifiedBy:30.
 i inspect.
 i asFloydSteinbergDitheredMonochromeImage inspect.
 i asBurkesDitheredMonochromeImage inspect.
 i asOrderedDitheredMonochromeImage inspect.
 asErrorDitheredMonochromeImage
 "return an error-diffusion dithered monochrome image from the receiver image."
 DitherAlgorithm == #burkes ifTrue:[
-^ self asBurkesDitheredMonochromeImage
+	^ self asBurkesDitheredMonochromeImage
 ].
 DitherAlgorithm == #stevensonArce ifTrue:[
-^ self asStevensonArceDitheredMonochromeImage
+	^ self asStevensonArceDitheredMonochromeImage
 ].
 ^ self asFloydSteinbergDitheredMonochromeImage
 "
 |i|
 "
 |i|
 i := Depth4Image
-width:4
+	     width:4
-height:4
+	     height:4
-fromArray:#[
+	     fromArray:#[
-16r01 16r23
+			    16r01 16r23
-16r45 16r67
+			    16r45 16r67
-16r89 16rab
+			    16r89 16rab
-16rcd 16ref
+			    16rcd 16ref
-].
+			].
 i := i magnifiedBy:30.
 i inspect.
 i asErrorDitheredMonochromeImage inspect.
 i asOrderedDitheredMonochromeImage inspect.
 "
 "Modified: 10.6.1996 / 14:22:30 / cg"
 !
 asFloydSteinbergDitheredDepth8FormOn:aDevice colors:fixColors
 "return a floyd-steinberg dithered pseudoForm from the picture.
 Use the colors in the fixColors array.
 By passing the ditherColors as extra array, this method can
 also be used to dither an 8bit image into a smaller number of colors,
 for example to create dithered Depth4Images from Depth8Images."
 |pseudoBits f deviceDepth map|
 deviceDepth := aDevice depth.
 deviceDepth == 8 ifFalse:[
-(aDevice supportedImageFormatForDepth:8) isNil ifTrue:[
+	(aDevice supportedImageFormatForDepth:8) isNil ifTrue:[
-^ nil.
+	    ^ nil.
-]
+	]
 ].
 pseudoBits := self floydSteinbergDitheredDepth8BitsColors:fixColors.
 pseudoBits isNil ifTrue:[^ nil].
 "/ have to create a funny colorMap, where
 "/ color at:index == color colorId:index
 "/
 map := Array new:256.
 fixColors do:[:clr |
-map at:clr colorId + 1 put:clr
+	map at:clr colorId + 1 put:clr
 ].
 f colorMap:map.
 f initGC.
 f bits:pseudoBits.
 aDevice
-drawBits:pseudoBits
+	drawBits:pseudoBits
-bitsPerPixel:8
+	bitsPerPixel:8
-depth:deviceDepth
+	depth:deviceDepth
-padding:8
+	padding:8
-width:width height:height
+	width:width height:height
-x:0 y:0
+	x:0 y:0
-into:(f id) x:0 y:0
+	into:(f id) x:0 y:0
-width:width height:height
+	width:width height:height
-with:(f gcId).
+	with:(f gcId).
 ^ f
 "
 example:
-color reduction from Depth8 to Depth4 (dithering) can be done by:
+	color reduction from Depth8 to Depth4 (dithering) can be done by:
 |img8 reducedImg8 img4 map form|
 map := #(
-(0     0   0)
+		  (0     0   0)
-(0     0 100)
+		  (0     0 100)
-(0    50   0)
+		  (0    50   0)
-(0    50 100)
+		  (0    50 100)
-(0   100   0)
+		  (0   100   0)
-(0   100 100)
+		  (0   100 100)
-(100   0   0)
+		  (100   0   0)
-(100   0 100)
+		  (100   0 100)
-(100  50   0)
+		  (100  50   0)
-(100  50 100)
+		  (100  50 100)
-(100 100   0)
+		  (100 100   0)
-(100 100 100)) collect:[:rgb | (Color red:(rgb at:1)
+		  (100 100 100)) collect:[:rgb | (Color red:(rgb at:1)
-green:(rgb at:2)
+						      green:(rgb at:2)
-blue:(rgb at:3)) onDevice:Display].
+						       blue:(rgb at:3)) onDevice:Display].
 img8 := Image fromFile:'goodies/bitmaps/bf.im8'.
 form := img8 paletteImageAsDitheredPseudoFormOn:Display
-colors:map
+		      colors:map
-nRed:2
+			nRed:2
-nGreen:3
+		      nGreen:3
-nBlue:2.
+		       nBlue:2.
 img8 := Depth8Image fromForm:form.    'dithered version of original image'.
 img4 := Depth4Image fromImage:img8.
 "
 "Modified: 14.6.1996 / 16:52:34 / cg"
 "Created: 23.6.1997 / 15:25:37 / cg"
 !
 asFloydSteinbergDitheredDepth8FormOn:aDevice colors:fixColors nRed:nRed nGreen:nGreen nBlue:nBlue
 "return a floyd-steinberg dithered pseudoForm from the palette picture.
 Use the colors in the fixColors array, which must be fixR x fixG x fixB
 colors assigned to aDevice, such as the preallocated colors of the
 Color class.
 By passing the ditherColors as extra array, this method can
 also be used to dither an 8bit image into a smaller number of colors,
 for example to create dithered Depth4Images from Depth8Images."
 |pseudoBits f deviceDepth map|
 deviceDepth := aDevice depth.
 deviceDepth == 8 ifFalse:[
-(aDevice supportedImageFormatForDepth:8) isNil ifTrue:[
+	(aDevice supportedImageFormatForDepth:8) isNil ifTrue:[
-^ nil
+	    ^ nil
-]
+	]
 ].
 pseudoBits := self floydSteinbergDitheredDepth8BitsColors:fixColors nRed:nRed nGreen:nGreen nBlue:nBlue.
 pseudoBits isNil ifTrue:[^ nil].
 "/ have to create a funny colorMap, where
 "/ color at:index == color colorId:index
 "/
 map := Array new:256.
 fixColors do:[:clr |
-map at:clr colorId + 1 put:clr
+	map at:clr colorId + 1 put:clr
 ].
 f colorMap:map.
 f initGC.
 f bits:pseudoBits.
 aDevice
-drawBits:pseudoBits
+	drawBits:pseudoBits
-bitsPerPixel:8
+	bitsPerPixel:8
-depth:deviceDepth
+	depth:deviceDepth
-padding:8
+	padding:8
-width:width height:height
+	width:width height:height
-x:0 y:0
+	x:0 y:0
-into:(f id) x:0 y:0
+	into:(f id) x:0 y:0
-width:width height:height
+	width:width height:height
-with:(f gcId).
+	with:(f gcId).
 ^ f
 "
 example:
-color reduction from Depth8 to Depth4 (dithering) can be done by:
+	color reduction from Depth8 to Depth4 (dithering) can be done by:
 |img8 reducedImg8 img4 map form|
 map := #(
-(0     0   0)
+		  (0     0   0)
-(0     0 100)
+		  (0     0 100)
-(0    50   0)
+		  (0    50   0)
-(0    50 100)
+		  (0    50 100)
-(0   100   0)
+		  (0   100   0)
-(0   100 100)
+		  (0   100 100)
-(100   0   0)
+		  (100   0   0)
-(100   0 100)
+		  (100   0 100)
-(100  50   0)
+		  (100  50   0)
-(100  50 100)
+		  (100  50 100)
-(100 100   0)
+		  (100 100   0)
-(100 100 100)) collect:[:rgb | (Color red:(rgb at:1)
+		  (100 100 100)) collect:[:rgb | (Color red:(rgb at:1)
-green:(rgb at:2)
+						      green:(rgb at:2)
-blue:(rgb at:3)) onDevice:Display].
+						       blue:(rgb at:3)) onDevice:Display].
 img8 := Image fromFile:'goodies/bitmaps/bf.im8'.
 form := img8 paletteImageAsDitheredPseudoFormOn:Display
-colors:map
+		      colors:map
-nRed:2
+			nRed:2
-nGreen:3
+		      nGreen:3
-nBlue:2.
+		       nBlue:2.
 img8 := Depth8Image fromForm:form.    'dithered version of original image'.
 img4 := Depth4Image fromImage:img8.
 "
 "Modified: 14.6.1996 / 16:52:34 / cg"
 "
 |i|
 i := Depth24Image width:4 height:1
 	  fromArray:#[
 	    16rFF 16r00 16r00   16rFF 16r00 16r00  16rFF 16r00 16r00  16rFF 16r00 16r00
 	    16rFF 16r00 16r00   16rFF 16r00 16r00  16rFF 16r00 16r00  16rFF 16r00 16r00
 	    16rFF 16r00 16r00   16rFF 16r00 16r00  16rFF 16r00 16r00  16rFF 16r00 16r00
 	    16rFF 16r00 16r00   16rFF 16r00 16r00  16rFF 16r00 16r00  16rFF 16r00 16r00].
 i := i magnifiedBy:4@1.
 "
 |i|
 i := Depth24Image width:4 height:6
 	  fromArray:#[
 	    16r00 16r00 16r00   16r00 16r00 16r80  16r00 16r00 16rff  16r00 16r80 16r00
 	    16r00 16r80 16r80   16r00 16rFF 16r00  16r00 16rFF 16r80  16r00 16rFF 16rFF
 	    16r80 16r00 16r00   16r80 16r00 16r80  16r80 16r00 16rff  16r80 16r80 16r00
 	    16r80 16r80 16r80   16r80 16rFF 16r00  16r80 16rFF 16r80  16r80 16rFF 16rFF
 	    16rFF 16r00 16r00   16rFF 16r00 16r80  16rFF 16r00 16rff  16rFF 16r80 16r00
 "
 |i|
 i := Depth4Image
 	     width:4
 	     height:4
 	     fromArray:#[
 			    16r01 16r23
 			    16r45 16r67
 			    16r89 16rab
 			    16rcd 16ref
 			].
 i := i magnifiedBy:30.
 i inspect.
 (i asFloydSteinbergDitheredGrayImageDepth:1) inspect.
 (i asFloydSteinbergDitheredGrayImageDepth:2) inspect.
 "
 |i|
 i := Depth4Image
 	     width:4
 	     height:4
 	     fromArray:#[
 			    16r01 16r23
 			    16r45 16r67
 			    16r89 16rab
 			    16rcd 16ref
 			].
 i := i magnifiedBy:30.
 i inspect.
 i asFloydSteinbergDitheredMonochromeImage inspect.
 i asBurkesDitheredMonochromeImage inspect.
 |pseudoBits pseudoBits8 f has8BitImage deviceDepth map d|
 deviceDepth := aDevice depth.
 has8BitImage := (deviceDepth == 8)
-or:[ (aDevice supportedImageFormatForDepth:8) notNil ].
+		    or:[ (aDevice supportedImageFormatForDepth:8) notNil ].
 has8BitImage ifFalse:[
-deviceDepth == 4 ifFalse:[^ nil].
+	deviceDepth == 4 ifFalse:[^ nil].
-pseudoBits8 := self nfloydSteinbergDitheredDepth8BitsColors:colors.
+	pseudoBits8 := self nfloydSteinbergDitheredDepth8BitsColors:colors.
-pseudoBits8 isNil ifTrue:[^ nil].
+	pseudoBits8 isNil ifTrue:[^ nil].
-"/ convert to devices depth
+	"/ convert to devices depth
-pseudoBits := ByteArray new:(width*4+7//8 * height).
+	pseudoBits := ByteArray new:(width*4+7//8 * height).
-pseudoBits8 compressPixels:4 width:width height:height into:pseudoBits mapping:nil.
+	pseudoBits8 compressPixels:4 width:width height:height into:pseudoBits mapping:nil.
-d := 4.
+	d := 4.
 ] ifTrue:[
-pseudoBits := self nfloydSteinbergDitheredDepth8BitsColors:colors.
+	pseudoBits := self nfloydSteinbergDitheredDepth8BitsColors:colors.
-pseudoBits isNil ifTrue:[^ nil].
+	pseudoBits isNil ifTrue:[^ nil].
-d := 8.
+	d := 8.
 ].
 f := Form width:width height:height depth:deviceDepth on:aDevice.
 f isNil ifTrue:[^ nil].
 "/ have to create a funny colorMap, where
 "/ color at:index == color colorId:index
 "/
 map := Array new:256 withAll:0.
 colors do:[:clr |
-clr notNil ifTrue:[
+	clr notNil ifTrue:[
-map at:clr colorId + 1 put:clr
+	    map at:clr colorId + 1 put:clr
-]
+	]
 ].
 f colorMap:map.
 f initGC.
 f bits:pseudoBits.
 aDevice
-drawBits:pseudoBits
+	drawBits:pseudoBits
-bitsPerPixel:d
+	bitsPerPixel:d
-depth:deviceDepth
+	depth:deviceDepth
-padding:8
+	padding:8
-width:width height:height
+	width:width height:height
-x:0 y:0
+	x:0 y:0
-into:(f id) x:0 y:0
+	into:(f id) x:0 y:0
-width:width height:height
+	width:width height:height
-with:(f gcId).
+	with:(f gcId).
 ^ f
 "
 |i|
 |form visual|
 ((aDevice == device) and:[deviceForm notNil]) ifTrue:[^ deviceForm].
 mask notNil ifTrue:[
-mask := mask onDevice:aDevice
+	mask := mask onDevice:aDevice
 ].
 (aDevice depth == 1
 or:[aDevice hasGrayscales not]) ifTrue:[
-form := self asMonochromeFormOn:aDevice.
+	form := self asMonochromeFormOn:aDevice.
 ] ifFalse:[
-((visual := aDevice visualType) == #StaticGray) ifTrue:[
+	((visual := aDevice visualType) == #StaticGray) ifTrue:[
-form := self asGrayFormOn:aDevice.
+	    form := self asGrayFormOn:aDevice.
-] ifFalse:[
+	] ifFalse:[
-(visual == #PseudoColor
+	    (visual == #PseudoColor
-or:[visual == #StaticColor]) ifTrue:[
+	     or:[visual == #StaticColor]) ifTrue:[
-form := self asPseudoFormQuickOn:aDevice.
+		form := self asPseudoFormQuickOn:aDevice.
-].
+	    ].
-]
+	]
 ].
 form isNil ifTrue:[
-(photometric == #palette) ifTrue:[
+	(photometric == #palette) ifTrue:[
-form := self paletteImageAsFormOn:aDevice
+	    form := self paletteImageAsFormOn:aDevice
-] ifFalse:[
+	] ifFalse:[
-(photometric == #rgb) ifTrue:[
+	    (photometric == #rgb) ifTrue:[
-form := self rgbImageAsFormOn:aDevice
+		form := self rgbImageAsFormOn:aDevice
-] ifFalse:[
+	    ] ifFalse:[
-(photometric == #cmy or:[photometric == #cmyk]) ifTrue:[
+		(photometric == #cmy or:[photometric == #cmyk]) ifTrue:[
-form := self rgbImageAsFormOn:aDevice
+		    form := self rgbImageAsFormOn:aDevice
-] ifFalse:[
+		] ifFalse:[
-form := self greyImageAsFormOn:aDevice
+		    form := self greyImageAsFormOn:aDevice
-]
+		]
-]
+	    ]
-].
+	].
 ].
 (device isNil or:[aDevice == device]) ifTrue:[
-"remember this form in the receiver ..."
+	"remember this form in the receiver ..."
-form notNil ifTrue:[
+	form notNil ifTrue:[
-form := form asImageForm.
+	    form := form asImageForm.
-deviceForm := form.
+	    deviceForm := form.
-maskedPixelsAre0 := nil.
+	    maskedPixelsAre0 := nil.
-device isNil ifTrue:[
+	    device isNil ifTrue:[
-device := aDevice.
+		device := aDevice.
-Lobby register:self
+		Lobby register:self
-] ifFalse:[
+	    ] ifFalse:[
-Lobby registerChange:self
+		Lobby registerChange:self
-].
+	    ].
-"
+	    "
-can save space, by not keeping the images data-bits
+	     can save space, by not keeping the images data-bits
-twice (here and in the device form)
+	     twice (here and in the device form)
-"
+	    "
-form forgetBits
+	    form forgetBits
-]
+	]
 ].
 ^ form
 "
 asGrayImageDepth:depth
 "get a gray image from the receiver"
 (self colorMap notNil and:[depth == self depth]) ifTrue:[
-^ self copyWithColorMapProcessing:[:clr | Color brightness:(clr brightness)].
+	^ self copyWithColorMapProcessing:[:clr | Color brightness:(clr brightness)].
 ].
 ^ self asGrayImageDepth:depth dither:DitherAlgorithm.
 "
 |i|
 |form|
 ((aDevice == device) and:[monoDeviceForm notNil]) ifTrue:[^ monoDeviceForm].
 self depth == 1 ifTrue:[
-((aDevice == device) and:[deviceForm notNil]) ifTrue:[^ deviceForm].
+	((aDevice == device) and:[deviceForm notNil]) ifTrue:[^ deviceForm].
-^ self asFormOn:aDevice
+	^ self asFormOn:aDevice
 ].
 form := self asMonochromeFormOn:aDevice dither:DitherAlgorithm.
 (device isNil or:[aDevice == device]) ifTrue:[
-"remember this form in the receiver ..."
+	"remember this form in the receiver ..."
-form notNil ifTrue:[
+	form notNil ifTrue:[
-form := form asImageForm.
+	    form := form asImageForm.
-monoDeviceForm := form.
+	    monoDeviceForm := form.
-device isNil ifTrue:[
+	    device isNil ifTrue:[
-device := aDevice.
+		device := aDevice.
-Lobby register:self
+		Lobby register:self
-] ifFalse:[
+	    ] ifFalse:[
-Lobby registerChange:self
+		Lobby registerChange:self
-].
+	    ].
-"
+	    "
-can save space, by not keeping the images data-bits
+	     can save space, by not keeping the images data-bits
-twice (here and in the device form)
+	     twice (here and in the device form)
-"
+	    "
-form forgetBits
+	    form forgetBits
-]
+	]
 ].
 ^ form
 "
 ^ self makeDeviceMonochromeBitmapOn:aDevice fromArray:monoBits
 "Modified: 10.6.1996 / 20:18:05 / cg"
 !
 asNearestPaintDepth8FormOn:aDevice colors:fixColors
 "return a nearest paint pseudoForm from the palette picture.
 Use the colors in the fixColors array.
 By passing the ditherColors as extra array, this method can
 also be used to dither an 8bit image into a smaller number of colors,
 for example to create dithered Depth4Images from Depth8Images."
 ^ self asNearestPaintDepth8FormOn:aDevice colors:fixColors nRed:nil nGreen:nil nBlue:nil.
 "
 example:
-color reduction from Depth8 to Depth4 can be done by:
+	color reduction from Depth8 to Depth4 can be done by:
 |img8 reducedImg8 img4 map form|
 map := #(
-(0     0   0)
+		  (0     0   0)
-(0     0 100)
+		  (0     0 100)
-(0    50   0)
+		  (0    50   0)
-(0    50 100)
+		  (0    50 100)
-(0   100   0)
+		  (0   100   0)
-(0   100 100)
+		  (0   100 100)
-(100   0   0)
+		  (100   0   0)
-(100   0 100)
+		  (100   0 100)
-(100  50   0)
+		  (100  50   0)
-(100  50 100)
+		  (100  50 100)
-(100 100   0)
+		  (100 100   0)
-(100 100 100)) collect:[:rgb | (Color red:(rgb at:1)
+		  (100 100 100)) collect:[:rgb | (Color red:(rgb at:1)
-green:(rgb at:2)
+						      green:(rgb at:2)
-blue:(rgb at:3)) onDevice:Display].
+						       blue:(rgb at:3)) onDevice:Display].
 img8 := Image fromFile:'goodies/bitmaps/claus.gif'.
 form := img8 asNearestPaintDepth8FormOn:Display
-colors:map
+		      colors:map
-nRed:2
+			nRed:2
-nGreen:3
+		      nGreen:3
-nBlue:2.
+		       nBlue:2.
 img8 := Depth8Image fromForm:form.    'dithered version of original image'.
 img4 := Depth4Image fromImage:img8.
 "
 "Modified: 17.6.1996 / 18:52:47 / cg"
 "Created: 23.6.1997 / 15:26:09 / cg"
 !
 asNearestPaintDepth8FormOn:aDevice colors:fixColors nRed:nRed nGreen:nGreen nBlue:nBlue
 "return a nearest paint pseudoForm from the palette picture.
 Use the colors in the fixColors array, which must be fixR x fixG x fixB
 colors assigned to aDevice, such as the preallocated colors of the
 Color class.
 By passing the ditherColors as extra array, this method can
 also be used to dither an 8bit image into a smaller number of colors,
 for example to create dithered Depth4Images from Depth8Images."
 |pseudoBits f deviceDepth map|
 deviceDepth := aDevice depth.
 deviceDepth == 8 ifFalse:[
-(aDevice supportedImageFormatForDepth:8) isNil ifTrue:[
+	(aDevice supportedImageFormatForDepth:8) isNil ifTrue:[
-^ nil
+	    ^ nil
-]
+	]
 ].
 pseudoBits := self nearestPaintDepth8BitsColors:fixColors nRed:nRed nGreen:nGreen nBlue:nBlue.
 pseudoBits isNil ifTrue:[^ nil].
 "/ have to create a funny colorMap, where
 "/ color at:index == color colorId:index
 "/
 map := Array new:256.
 fixColors do:[:clr |
-map at:clr colorId + 1 put:clr
+	map at:clr colorId + 1 put:clr
 ].
 f colorMap:map.
 f initGC.
 f bits:pseudoBits.
 aDevice
-drawBits:pseudoBits
+	drawBits:pseudoBits
-bitsPerPixel:8
+	bitsPerPixel:8
-depth:deviceDepth
+	depth:deviceDepth
-padding:8
+	padding:8
-width:width height:height
+	width:width height:height
-x:0 y:0
+	x:0 y:0
-into:(f id) x:0 y:0
+	into:(f id) x:0 y:0
-width:width height:height
+	width:width height:height
-with:(f gcId).
+	with:(f gcId).
 ^ f
 "
 example:
-color reduction from Depth8 to Depth4 (dithering) can be done by:
+	color reduction from Depth8 to Depth4 (dithering) can be done by:
 |img8 reducedImg8 img4 map form|
 map := #(
-(0     0   0)
+		  (0     0   0)
-(0     0 100)
+		  (0     0 100)
-(0    50   0)
+		  (0    50   0)
-(0    50 100)
+		  (0    50 100)
-(0   100   0)
+		  (0   100   0)
-(0   100 100)
+		  (0   100 100)
-(100   0   0)
+		  (100   0   0)
-(100   0 100)
+		  (100   0 100)
-(100  50   0)
+		  (100  50   0)
-(100  50 100)
+		  (100  50 100)
-(100 100   0)
+		  (100 100   0)
-(100 100 100)) collect:[:rgb | (Color red:(rgb at:1)
+		  (100 100 100)) collect:[:rgb | (Color red:(rgb at:1)
-green:(rgb at:2)
+						      green:(rgb at:2)
-blue:(rgb at:3)) onDevice:Display].
+						       blue:(rgb at:3)) onDevice:Display].
 img8 := Image fromFile:'goodies/bitmaps/claus.gif'.
 form := img8 asNearestPaintDepth8FormOn:Display
-colors:map
+		      colors:map
-nRed:2
+			nRed:2
-nGreen:3
+		      nGreen:3
-nBlue:2.
+		       nBlue:2.
 img8 := Depth8Image fromForm:form.    'dithered version of original image'.
 img4 := Depth4Image fromImage:img8.
 "
 "Created: 17.6.1996 / 18:47:46 / cg"
 "Modified: 17.6.1996 / 18:52:47 / cg"
 !
 asNearestPaintImageDepth:d colors:colors
 "return a threshold image from the receiver picture, using colors in colors."
 |newBits|
 d ~~ 8 ifTrue:[
 Uses an 8x8 dithermatrix."
 |depth bits|
 depth := aDevice depth.
 (depth == 1
 or:[aDevice hasGrayscales not]) ifTrue:[
 	"/ for monochrome, there is highly specialized
 	"/ monochrome dither code available
 	^ self asOrderedDitheredMonochromeFormOn:aDevice
 |dither|
 dither := self class orderedDitherMatrixOfSize:8.
 (depth == 1) ifTrue:[
-"/ for monochrome, there is highly specialized
+	"/ for monochrome, there is highly specialized
-"/ monochrome dither code available
+	"/ monochrome dither code available
-^ Depth1Image
+	^ Depth1Image
-width:width
+	    width:width
-height:height
+	    height:height
-fromArray:(
+	    fromArray:(
-self
+		self
-orderedDitheredMonochromeBitsWithDitherMatrix:dither
+		    orderedDitheredMonochromeBitsWithDitherMatrix:dither
-ditherWidth:8)
+		    ditherWidth:8)
 ].
 ^ (self class implementorForDepth:depth)
-width:width
+	width:width
-height:height
+	height:height
-fromArray:(
+	fromArray:(
-self
+	    self
-orderedDitheredGrayBitsWithDitherMatrix:dither
+		orderedDitheredGrayBitsWithDitherMatrix:dither
-ditherWidth:8
+		ditherWidth:8
-depth:depth)
+		depth:depth)
 "
 |i i1 i2 i4 i8|
 i := Image fromFile:'goodies/bitmaps/gifImages/claus.gif'.
 "/
 "/ could look at the image and decide upon the number of
 "/ distinct colors present. Use 8x8 for high-number,
 "/ 4x4 for small number of colors ...
 ^ self
-asOrderedDitheredMonochromeFormOn:aDevice
+	asOrderedDitheredMonochromeFormOn:aDevice
-ditherMatrix:(self class orderedDitherMatrixOfSize:4)
+	ditherMatrix:(self class orderedDitherMatrixOfSize:4)
-ditherWidth:4
+	ditherWidth:4
 "/    ^ self
 "/        asOrderedDitheredMonochromeFormOn:aDevice
 "/        ditherMatrix:(self class orderedDitherMatrixOfSize:8)
 "/        ditherWidth:8
 "
 |i f|
 "/
 "/ could look at the image and decide upon the number of
 "/ distinct colors present. Use 8x8 for high-number,
 "/ 4x4 for small number of colors ...
 ^ self
-asOrderedDitheredMonochromeImageWithDitherMatrix:(self class orderedDitherMatrixOfSize:4)
+	asOrderedDitheredMonochromeImageWithDitherMatrix:(self class orderedDitherMatrixOfSize:4)
-ditherWidth:4
+	ditherWidth:4
 "/    ^ self
 "/        asOrderedDitheredMonochromeImageWithDitherMatrix:(self class orderedDitherMatrixOfSize:8)
 "/        ditherWidth:8
 "
 |i|
 |i|
 i := Image fromFile:'goodies/bitmaps/gifImages/garfield.gif'.
 i
-asOrderedDitheredMonochromeImageWithDitherMatrix:(Image orderedDitherMatrixOfSize:4)
+	asOrderedDitheredMonochromeImageWithDitherMatrix:(Image orderedDitherMatrixOfSize:4)
-ditherWidth:4
+	ditherWidth:4
 "
 "order-6 dither:
 |i|
 i := Image fromFile:'goodies/bitmaps/gifImages/garfield.gif'.
 i
-asOrderedDitheredMonochromeImageWithDitherMatrix:(Image orderedDitherMatrixOfSize:8)
+	asOrderedDitheredMonochromeImageWithDitherMatrix:(Image orderedDitherMatrixOfSize:8)
-ditherWidth:8
+	ditherWidth:8
 "
 "thresholding at:0.5 (all above 0.5 becomes white):
 |i|
 i := Image fromFile:'goodies/bitmaps/gifImages/garfield.gif'.
 i
-asOrderedDitheredMonochromeImageWithDitherMatrix:(ByteArray new:16 withAll:8)
+	asOrderedDitheredMonochromeImageWithDitherMatrix:(ByteArray new:16 withAll:8)
-ditherWidth:4
+	ditherWidth:4
 "
 "thresholding at: 0.25 (all above 0.25 becomes white):
 |i|
 i := Image fromFile:'goodies/bitmaps/gifImages/garfield.gif'.
 i
-asOrderedDitheredMonochromeImageWithDitherMatrix:(ByteArray new:16 withAll:3)
+	asOrderedDitheredMonochromeImageWithDitherMatrix:(ByteArray new:16 withAll:3)
-ditherWidth:4
+	ditherWidth:4
 "
 "thresholding at: 0.75 (all above 0.75 becomes white):
 |i|
 i := Image fromFile:'goodies/bitmaps/gifImages/garfield.gif'.
 i
-asOrderedDitheredMonochromeImageWithDitherMatrix:(ByteArray new:16 withAll:11)
+	asOrderedDitheredMonochromeImageWithDitherMatrix:(ByteArray new:16 withAll:11)
-ditherWidth:4
+	ditherWidth:4
 "
 "Modified: 7.6.1996 / 17:23:47 / cg"
 !
 asPseudoFormQuickOn:aDevice
 "return a pseudo-deviceForm from the image.
 Fail if any color is not available (i.e. do not dither)."
 |f d
 temp temp8 bits clr cMap idMap
 w            "{ Class: SmallInteger }"
 h            "{ Class: SmallInteger }"
 dDev         "{ Class: SmallInteger }"
 nClr         "{ Class: SmallInteger }"
 bytesPerLine "{ Class: SmallInteger }"
 usedColors pix fmt bytes|
 d := self depth.
 (d == 1
 (d == 8 and:[dDev == 8]) ifTrue:[
 	"/ only translate
 	temp := ByteArray uninitializedNew:(w * h).
 	bytes expandPixels:8         "xlate only"
 		    width:w
 		   height:h
 		     into:temp
 		  mapping:idMap.
 ] ifFalse:[
 	"/ stupid: expandPixels can only handle any-to-8
 	"/ then from 8 to the device depth.
 	d ~~ 8 ifTrue:[
 	    temp8 := ByteArray uninitializedNew:(w * h).
 	    bytes expandPixels:d
 			 width:w
 			height:h
 			  into:temp8
 		       mapping:idMap.
 	    idMap := nil.
 	] ifFalse:[
 	].
 	dDev ~~ 8 ifTrue:[
 	    temp := ByteArray uninitializedNew:(bytesPerLine * h).
 	    temp8 compressPixels:dDev
 			 width:w
 			height:h
 			  into:temp
 		       mapping:idMap.
 	] ifFalse:[
 	    temp := temp8
 ].
 f := Form width:w height:h depth:dDev on:aDevice.
 f isNil ifTrue:[^ nil].
 f colorMap:cMap.
 f initGC.
 aDevice
 	drawBits:temp
 	depth:dDev
 	padding:8
 	width:w
 	height:h
 	x:0 y:0
 	into:(f id) x:0 y:0
 	width:w
 	height:h
 	with:(f gcId).
 ^ f
 "
 (
 	(((Depth4Image
 	     width:4
 	     height:4
 	     fromArray:#[
 			    16r01 16r23
 			    16r45 16r67
 			    16r89 16rab
 			    16rcd 16ref
 			]))
 	       magnifiedBy:30
 	 )
 	  asPseudoFormQuickOn:Display
 ) inspect
 "
 |i|
 i := Depth4Image
-width:4
+	     width:4
-height:4
+	     height:4
-fromArray:#[
+	     fromArray:#[
-16r01 16r23
+			    16r01 16r23
-16r45 16r67
+			    16r45 16r67
-16r89 16rab
+			    16r89 16rab
-16rcd 16ref
+			    16rcd 16ref
-].
+			].
 i := i magnifiedBy:30.
 i inspect.
 i asStevensonArceDitheredMonochromeImage inspect.
 i asOrderedDitheredMonochromeImage inspect.
 "
 (depth := aDevice depth) == 1 ifTrue:[
 	^ self asThresholdMonochromeFormOn:aDevice
 ].
 ^ self
 	makeDeviceGrayPixmapOn:aDevice
 	depth:depth
 	fromArray:(self
 			orderedDitheredGrayBitsWithDitherMatrix:#[8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8]
 			ditherWidth:4
 			depth:depth)
 !
 asThresholdMonochromeFormOn:aDevice
 "return a threshold monochrome form from the image."
 ^ self
 	asOrderedDitheredMonochromeFormOn:aDevice
 	ditherMatrix:#[8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8]
 	ditherWidth:4
 "
 |i|
 !
 fromImage:anImage
 "setup the receiver from another image.
 Color precision may be lost, if conversion is from a higher depth
 image.
 WARNING:
 This implementation is a slow fallback (the loop over the
 source pixels is very slow). If this method is used heavily, you
 may want to redefine it in concrete subclasses for common source images."
 !
 fromImage:anImage photometric:photometricOrNil
 "setup the receiver from another image and optionally set the photometric.
 Color precision may be lost, if conversion is from a higher depth
 image.
 WARNING:
 This implementation is a slow fallback (the loop over the
 source pixels is very slow). If this method is used heavily, you
 may want to redefine it in concrete subclasses for common source images."
 ((photometric == anImage photometric)
 and:[self bitsPerPixel = anImage bitsPerPixel
 and:[colorMap = anImage colorMap]]) ifTrue:[
 	"/ can do it by value
 	anImage
 	    valuesFromX:xL y:yT toX:xR y:yB
 	    do:[:x :y :pixelValue |
 		    self pixelAtX:x-xL y:y-yT put:pixelValue.
 	       ]
 ] ifFalse:[
 	"/ must do it by colors
 	anImage
 	    colorsFromX:xL y:yT toX:xR y:yB
 	    do:[:x :y :clr |
 		    self colorAtX:x-xL y:y-yT put:clr.
 	       ]
 ].
 	anImage mask depth == 1 ifTrue:[
 	    maskClass := ImageMask
 	] ifFalse:[
 	    maskClass := anImage mask class.
 	].
 	mask := maskClass new
 		    fromSubImage:anImage mask in:aRectangle
 ].
 "
 |i i2 i4 i8 i16 i24|
 !
 greyImageAsPseudoFormOn:aDevice
 "return an 8-bit pseudo Form from the grey image"
 |wideBits pictureDepth f map
 colorMap usedColors nUsed aColor
 nColors "{ Class: SmallInteger }"
 range id
 cube nR nG nB grayColors
 fit|
 	 to avoid allocating too many colors"
 	(grayColors := aDevice fixGrayColors) notNil ifTrue:[
 	    DitherAlgorithm == #floydSteinberg ifTrue:[
 		f := self
 		       asFloydSteinbergDitheredDepth8FormOn:aDevice
 		       colors:grayColors
 	    ].
 	    f notNil ifTrue:[^ f].
 	].
 	(cube := aDevice fixColors) notNil ifTrue:[
 	    nG := aDevice numFixGreen.
 	    nB := aDevice numFixBlue.
 	    DitherAlgorithm == #floydSteinberg ifTrue:[
 		f := self
 		       asFloydSteinbergDitheredDepth8FormOn:aDevice
 		       colors:cube
 		       nRed:nR
 		       nGreen:nG
 		       nBlue:nB.
 	    ] ifFalse:[
 		f := self
 		       asNearestPaintDepth8FormOn:aDevice
 		       colors:cube
 		       nRed:nR
 		       nGreen:nG
 		       nBlue:nB.
 	    ].
 	    f notNil ifTrue:[^ f].
 	"/ Must dither.
 ].
 "expand & translate"
 self bits
 	expandPixels:pictureDepth
 	width:width height:height
 	into:wideBits
 	mapping:map.
 f := Form width:width height:height depth:8 on:aDevice.
 f isNil ifTrue:[^ nil].
 f colorMap:colorMap.
 f initGC.
 aDevice
 	drawBits:wideBits
 	depth:8
 	padding:8
 	width:width height:height
 	x:0 y:0
 	into:(f id)
 	x:0 y:0
 	width:width height:height
 	with:(f gcId).
 ^ f
 "Modified: 19.10.1997 / 05:19:44 / cg"
 !
 greyImageAsTrueColorFormOn:aDevice
 "return a true-color device-form for the grey-image receiver.
 TODO: the pixel loops ought to be implemented as inline primitive code ..."
 |depth
 myDepth    "{ Class: SmallInteger }"
 nColors    "{ Class: SmallInteger }"
 colorValues
 scaleDown
 scaleRed   "{ Class: SmallInteger }"
 scaleGreen "{ Class: SmallInteger }"
 scaleBlue  "{ Class: SmallInteger }"
 redShift   "{ Class: SmallInteger }"
 blueShift  "{ Class: SmallInteger }"
 greenShift "{ Class: SmallInteger }"
 form bestFormat usedDeviceDepth usedDeviceBitsPerPixel imageBits
 greyValue  "{ Class: SmallInteger }"
 h          "{ Class: SmallInteger }"
 w          "{ Class: SmallInteger }"
 pixelArray newPixelArray i|
 form := Form width:width height:height depth:usedDeviceDepth on:aDevice.
 form isNil ifTrue:[^ nil].
 form initGC.
 form
 	copyBitsFrom:imageBits
 	bitsPerPixel:usedDeviceBitsPerPixel
 	depth:usedDeviceDepth
 	padding:8
 	width:width height:height
 	x:0 y:0
 	toX:0 y:0.
 ^ form
 "Created: 20.10.1995 / 22:05:10 / cg"
 "Modified: 24.4.1997 / 23:11:16 / cg"
 "return a pseudo-deviceForm from the palette image."
 |tempImage d temp8|
 d := self depth.
 (#(1 2 4 8) includes:d) ifTrue:[
 	"
 	 fallback code for some depth's:
 	 create a temporary Depth8Image and use its conversion method
 	"
 	temp8 := ByteArray uninitializedNew:(width * height).
 	self bits
 	    expandPixels:d
 	    width:width height:height
 	    into:temp8
 	    mapping:nil.
 	tempImage := Image width:width height:height depth:8 fromArray:temp8.
 !
 paletteImageAsTrueColorFormOn:aDevice
 "return a true-color device-form for the palette-image receiver."
 |depth
 nColors "{ Class: SmallInteger }"
 h       "{ Class: SmallInteger }"
 pixel   "{ Class: SmallInteger }"
 colorValues
 scaleRed scaleGreen scaleBlue redShift greenShift blueShift
 form imageBits bestFormat usedDeviceDepth usedDeviceBitsPerPixel
 i pixelArray newPixelArray
 clr r g b rv gv bv v "{ Class: SmallInteger }" |
 "/ this is a slow fallback method; this ought to be
 "/ redefined in DepthxImage for more performance.
 depth := aDevice depth.
 bestFormat := self bestSupportedImageFormatFor:aDevice.
 usedDeviceDepth := bestFormat at:#depth.
 usedDeviceDepth == 1 ifTrue:[
-^ self asMonochromeFormOn:aDevice.
+	^ self asMonochromeFormOn:aDevice.
 ].
 usedDeviceBitsPerPixel := bestFormat at:#bitsPerPixel.
 scaleRed := ((1 bitShift:aDevice bitsRed) - 1) / 255.
 greenShift := aDevice shiftGreen.
 blueShift := aDevice shiftBlue.
 nColors := colorMap size.
 nColors <= 4096 ifTrue:[
-"/ precompute scales to map from 0..100 into devices range
+	"/ precompute scales to map from 0..100 into devices range
-"/ (this may be different for the individual components)
+	"/ (this may be different for the individual components)
-colorValues := Array uninitializedNew:nColors.
+	colorValues := Array uninitializedNew:nColors.
-1 to:nColors do:[:index |
+	1 to:nColors do:[:index |
-r := colorMap redByteAt:index.
+	    r := colorMap redByteAt:index.
-g := colorMap greenByteAt:index.
+	    g := colorMap greenByteAt:index.
-b := colorMap blueByteAt:index.
+	    b := colorMap blueByteAt:index.
 "/        clr := colorMap at:index.
-true "clr notNil" ifTrue:[
+	    true "clr notNil" ifTrue:[
 "/            r := clr red.
 "/            g := clr green.
 "/            b := clr blue.
-rv := (r * scaleRed) rounded.
+		rv := (r * scaleRed) rounded.
-gv := (g * scaleGreen) rounded.
+		gv := (g * scaleGreen) rounded.
-bv := (b * scaleBlue) rounded.
+		bv := (b * scaleBlue) rounded.
-v := rv bitShift:redShift.
+		v := rv bitShift:redShift.
-v := v bitOr:(gv bitShift:greenShift).
+		v := v bitOr:(gv bitShift:greenShift).
-v := v bitOr:(bv bitShift:blueShift).
+		v := v bitOr:(bv bitShift:blueShift).
-colorValues at:index put:v.
+		colorValues at:index put:v.
 "/ clr print. ' ' print.
 "/ rv print. ' ' print. gv print. ' ' print. bv print. ' ' print.
 "/ ' -> ' print. v printNL.
-]
+	    ]
-].
+	].
 ].
 "/ the temporary helper image is only needed to allow
 "/ the rowAt:putAll: calls below.
 h := height - 1.
 pixelArray := self pixelArraySpecies new:width.
 newPixelArray := i pixelArraySpecies new:width.
 colorValues notNil ifTrue:[
-0 to:h do:[:y |
+	0 to:h do:[:y |
-self rowAt:y into:pixelArray.
+	    self rowAt:y into:pixelArray.
-1 to:width do:[:x |
+	    1 to:width do:[:x |
-pixel := pixelArray at:x.
+		pixel := pixelArray at:x.
-newPixelArray at:x put:(colorValues at:pixel + 1).
+		newPixelArray at:x put:(colorValues at:pixel + 1).
-].
+	    ].
-i rowAt:y putAll:newPixelArray.
+	    i rowAt:y putAll:newPixelArray.
-].
+	].
 ] ifFalse:[
-0 to:h do:[:y |
+	0 to:h do:[:y |
-self rowAt:y into:pixelArray.
+	    self rowAt:y into:pixelArray.
-1 to:width do:[:x |
+	    1 to:width do:[:x |
-pixel := pixelArray at:x.
+		pixel := pixelArray at:x.
-clr := self colorFromValue:pixel.
+		clr := self colorFromValue:pixel.
-r := clr redByte.
+		r := clr redByte.
-g := clr greenByte.
+		g := clr greenByte.
-b := clr blueByte.
+		b := clr blueByte.
-rv := (r * scaleRed) rounded.
+		rv := (r * scaleRed) rounded.
-gv := (g * scaleGreen) rounded.
+		gv := (g * scaleGreen) rounded.
-bv := (b * scaleBlue) rounded.
+		bv := (b * scaleBlue) rounded.
-v := rv bitShift:redShift.
+		v := rv bitShift:redShift.
-v := v bitOr:(gv bitShift:greenShift).
+		v := v bitOr:(gv bitShift:greenShift).
-v := v bitOr:(bv bitShift:blueShift).
+		v := v bitOr:(bv bitShift:blueShift).
-newPixelArray at:x put:v.
+		newPixelArray at:x put:v.
-].
+	    ].
-i rowAt:y putAll:newPixelArray.
+	    i rowAt:y putAll:newPixelArray.
-].
+	].
 ].
 form := Form width:width height:height depth:usedDeviceDepth on:aDevice.
 form isNil ifTrue:[^ nil].
 form initGC.
 form
-copyBitsFrom:imageBits
+	copyBitsFrom:imageBits
-bitsPerPixel:usedDeviceBitsPerPixel
+	bitsPerPixel:usedDeviceBitsPerPixel
-depth:usedDeviceDepth
+	depth:usedDeviceDepth
-padding:8
+	padding:8
-width:width height:height
+	width:width height:height
-x:0 y:0
+	x:0 y:0
-toX:0 y:0.
+	toX:0 y:0.
 ^ form
 "Modified: / 24.7.1998 / 00:56:14 / cg"
 ! !
 !Image methodsFor:'converting rgb images'!
 asDitheredTrueColor8FormOn:aDevice
 "convert an rgb image to a dithered depth8-form on aDevice.
 Return the device-form.
 This method is only valid for trueColor displays."
 |fixColors pixel
 dstIdx     "{ Class: SmallInteger }"
 shiftRed   "{ Class: SmallInteger }"
 	    ]
 	]
 ].
 ^ self
 	asFloydSteinbergDitheredDepth8FormOn:aDevice
 	colors:fixColors
 	nRed:nRed nGreen:nGreen nBlue:nBlue
 "Created: 14.6.1996 / 17:23:52 / cg"
 "Modified: 23.6.1997 / 15:22:36 / cg"
 !
 	'Image [warning]: display bitmap creation failed' errorPrintCR.
 	^ nil
 ].
 form initGC.
 form
 	copyBitsFrom:self bits
 	bitsPerPixel:usedDeviceBitsPerPixel
 	depth:usedDeviceDepth
 	padding:8
 	width:width height:height
 	x:0 y:0
 	toX:0 y:0.
 ^ form
 "Modified: 10.1.1997 / 17:53:23 / cg"
 ! !
 errorArray1
 e t
 w               "{Class: SmallInteger }"
 h               "{Class: SmallInteger }"
 bitCnt          "{Class: SmallInteger }"
 byte            "{Class: SmallInteger }"
 grey|
 self depth > 12 ifTrue:[
 	^ self floydSteinbergDitheredMonochromeBits
 ].
 "/ fetch scaled brightness values outside of loop into a table;
 "/ use table-value in loop
 greyValues := self greyMapForRange:(255*1024).
 0 to:(h-1) do:[:y |
 	nextDst := dstIndex + bytesPerMonoRow.
 	byte := 0.
 	bitCnt := 8.
 	errorArray1 := t.
 	errorArray1 atAllPut:0.
 	self valuesAtY:y from:0 to:(w-1) do:[:x :pixel |
 	    |eP "{Class: SmallInteger }"
 	     eD
 	     eI "{Class: SmallInteger }"
 	     xE "{Class: SmallInteger }"
 	     xN "{Class: SmallInteger }" |
 	    "/ get the colors grey value [0 .. 1]
 	    grey := greyValues at:(pixel + 1).
 "Modified: 10.6.1996 / 13:16:33 / cg"
 !
 floydSteinbergDitheredDepth8BitsColors:colors
 "return a floyd-steinberg dithered bitmap from the receiver picture,
 which must be a depth-8 image.
 This method expects an array of colors to be used for dithering
 (which need not be a colorCubes colors)."
 ^ self floydSteinbergDitheredDepth8BitsColors:colors map:nil
 !
 floydSteinbergDitheredDepth8BitsColors:colors map:aMapOrNil
 "return a floyd-steinberg dithered bitmap from the receiver picture,
 which must be a depth-24 image.
 This method expects an array of colors to be used for dithering
 (which need not be a colorCubes colors)."
 |pseudoBits
 ditherRGBBytes ditherColors
 w       "{Class: SmallInteger }"
 h       "{Class: SmallInteger }"
 index   "{Class: SmallInteger }"
 ditherIds failed lastColor qScramble
 	i := qScramble at:((r bitShift:-4) bitAnd:16r0F) + 1.
 	i := i + ((qScramble at:((g bitShift:-4) bitAnd:16r0F) + 1) bitShift:-1).
 	i := i + ((qScramble at:((b bitShift:-4) bitAnd:16r0F) + 1) bitShift:-2).
 	lookupPos := i.
 	[index < lookupPos] whileTrue:[
 	    clrLookup at:(index+1) put:(clrPosition-1-1).
 	    index := index + 1
 	]
 ].
 clrLookup from:index+1 to:4096 put:(ditherColors size - 1).
 		 && (__wantG == __wG)
 		 && (__wantB == __wB)) {
 		    /*
 		     * same color again - reuse last bestMatch
 		     */
 		} else
 #endif
 		{
 		    __wR = __wantR;
 		    __wG = __wantG;
 		    __wB = __wantB;
 			d = dp[0];
 			delta = (__wR - d) * RED_SCALE;
 			if (delta < 0) delta = -delta;
 			d = dp[1];
 			if (__wG > d)
 			    delta += (__wG - d) * GREEN_SCALE;
 			else
 			    delta += (d - __wG) * GREEN_SCALE;
 			d = dp[2];
 			if (__wB > d)
 			    delta += (__wB - d) * BLUE_SCALE;
 			else
 			    delta += (d - __wB) * BLUE_SCALE;
 			if (delta <= GOOD_DELTA) {
 			    goto foundBest;
 			}
 			    idx--; dp -= 3;
 			    d = dp[0];
 			    delta = (__wR - d) * RED_SCALE;
 			    if (delta < 0) delta = -delta;
 			    d = dp[1];
 			    if (__wG > d)
 				delta += (__wG - d) * GREEN_SCALE;
 			    else
 				delta += (d - __wG) * GREEN_SCALE;
 			    d = dp[2];
 			    if (__wB > d)
 				delta += (__wB - d) * BLUE_SCALE;
 			    else
 				delta += (d - __wB) * BLUE_SCALE;
 			    if (delta < minDelta) {
 				bestIdx = idx;
 				if (delta <= GOOD_DELTA) {
 			    dp += 3;
 			    d = dp[0];
 			    delta = (__wR - d) * RED_SCALE;
 			    if (delta < 0) delta = -delta;
 			    d = dp[1];
 			    if (__wG > d)
 				delta += (__wG - d) * GREEN_SCALE;
 			    else
 				delta += (d - __wG) * GREEN_SCALE;
 			    d = dp[2];
 			    if (__wB > d)
 				delta += (__wB - d) * BLUE_SCALE;
 			    else
 				delta += (d - __wB) * BLUE_SCALE;
 			    if (delta < minDelta) {
 				bestIdx = idx;
 				if (delta <= GOOD_DELTA) {
 			d = dp[0];
 			delta = (__wR - d) * RED_SCALE;
 			if (delta < 0) delta = -delta;
 			if (delta < minDelta) {
 			    d = dp[1];
 			    if (__wG > d)
 				delta += (__wG - d) * GREEN_SCALE;
 			    else
 				delta += (d - __wG) * GREEN_SCALE;
 			    if (delta < minDelta) {
 				d = dp[2];
 				if (__wB > d)
 				    delta += (__wB - d) * BLUE_SCALE;
 				else
 				    delta += (d - __wB) * BLUE_SCALE;
 				if (delta < minDelta) {
 				    bestIdx = idx;
 				    if (delta <= GOOD_DELTA) {
 		dR = dp[0];
 		dG = dp[1];
 		dB = dp[2];
 /*
-printf("want: %d/%d/%d (%d/%d/%d) got: %d/%d/%d\n",
+console_printf("want: %d/%d/%d (%d/%d/%d) got: %d/%d/%d\n",
 		__wantR, __wantG, __wantB,
 		__wR, __wG, __wB,
 		dR, dG, dB);
 */
 		/*
 		*dstP++ = idP[bestIdx];
 		/*
 		 * the new error & distribute the error
 		 */
 		__eR = __wantR - dR;
 		if (__eR) {
 		    tR = __eR >> 4;  /* 16th of error */
 		    nR = eP[3] + (tR * 7);/* from accu: error for (x+1 / y) */
 		    eP[0] = tR*5;         /* 5/16th for (x / y+1) */
 		    eP[-3] = tR*3;        /* 3/16th for (x-1 / y+1) */
 		} else {
 		    __eG = eP[4];
 		    eP[1] = eP[-2] = eP[4] = 0;
 		}
 		__eB = __wantB - dB;
 		if (__eB) {
 		    tB = __eB >> 4;
 		    nB = eP[5] + (tB * 7);
 		    eP[2] = tB*5;
 		    eP[-1] = tB*3;
 ].
 ^ pseudoBits
 !
 floydSteinbergDitheredDepth8BitsColors:fixColors nRed:nRed nGreen:nGreen nBlue:nBlue
 "return a floyd-steinberg dithered bitmap from the receiver picture,
 which must be a depth-8 image.
 This is a special-cased dither method for 8-bit palette images being displayed on
 an 8-bit pseudoColor display, AND fixColor dithering is used.
 Use the colors in the fixColors array, which must be fixR x fixG x fixB
 colors assigned to aDevice, such as the preallocated colors of the
 Color class.
 By passing the ditherColors as extra array, this method can
 also be used to dither an 8bit image into a smaller number of colors,
 for example to create dithered Depth4Images from Depth8Images."
 |pseudoBits
 rgbBytes
 w       "{Class: SmallInteger }"
 h       "{Class: SmallInteger }"
 index   "{Class: SmallInteger }"
 fixR    "{Class: SmallInteger }"
 fixG    "{Class: SmallInteger }"
 fixB    "{Class: SmallInteger }"
 fixGfixB
 fixIds failed map lastColor
 rgbIDX  "{Class: SmallInteger }"
 idxAndErrRBytes idxAndErrGBytes idxAndErrBBytes
 error clr|
 self depth ~~ 8 ifTrue:[^ nil].
 	rgbIDX := (i * (fixR-1) + 128) // 255. "red index rounded"
 	idxAndErrRBytes at:index put:(rgbIDX * fixGfixB).
 	idxAndErrRBytes at:index+1 put:i - (rgbIDX * 255 // (fixR-1)) + 128.
 	rgbIDX := (i * (fixG-1) + 128) // 255. "green index rounded"
 	idxAndErrGBytes at:index put:(rgbIDX * fixB).
 	idxAndErrGBytes at:index+1 put:i - (rgbIDX * 255 // (fixG-1)) + 128.
 	rgbIDX := (i * (fixB-1) + 128) // 255. "blue index rounded"
 	idxAndErrBBytes at:index put:(rgbIDX ).
 	idxAndErrBBytes at:index+1 put:i - (rgbIDX * 255 // (fixB-1)) + 128.
 		 */
 		__want = rgbP[pix]   + __eR;
 		if (__want > 255) __want = 255;
 		else if (__want < 0) __want = 0;
 		__want += __want;
 		idx = __idxAndErrRBytes[__want];
 		__eR = __idxAndErrRBytes[__want+1];
 		__eR -= 128;
 		__want = rgbP[pix+1] + __eG;
 		if (__want > 255) __want = 255;
 		else if (__want < 0) __want = 0;
 		__want += __want;
 		idx += __idxAndErrGBytes[__want];
 		__eG = __idxAndErrGBytes[__want+1];
 		__eG -= 128;
 		__want = rgbP[pix+2] + __eB;
 		if (__want > 255) __want = 255;
 		else if (__want < 0) __want = 0;
 		__want += __want;
 		idx += __idxAndErrBBytes[__want];
 		__eB = __idxAndErrBBytes[__want+1];
 		__eB -= 128;
 		/*
 		 * store the corresponding dither colors colorId
 		 */
 !
 floydSteinbergDitheredGrayBitsDepth:depth
 "return the bits for dithering a gray image from the image.
 Works for any source depths / photometric,
 but possibly slow since each pixel is processed individually.
 Redefined by some subclasses for more performance (D8Image/D24Image)"
 |dstIndex        "{Class: SmallInteger }"
 nextDst         "{Class: SmallInteger }"
 nextErrorArray
 t
 w               "{Class: SmallInteger }"
 h               "{Class: SmallInteger }"
 bitCnt          "{Class: SmallInteger }"
 byte            "{Class: SmallInteger }"
 grey
 eR eRB eB eLB |
 depth > 8 ifTrue:[
 	self error:'unimplemented conversion'.
 	    self valuesAtY:y from:0 to:(w-1) do:[:x :value |
 		|e     "{ Class: SmallInteger }"
 		 pixel "{ Class: SmallInteger }"
 		 error "{ Class: SmallInteger }"
 		 e16   "{ Class: SmallInteger }"
 		 xE    "{ Class: SmallInteger }"
 		 xN    "{ Class: SmallInteger }" |
 		pixel := greyPixels at:(value + 1).
 		"/ adjust error
 		xE := x + 2.
 		error := (greyErrors at:(value + 1)) + (errorArray at:xE).
 		byte := byte bitShift:depth.
 		error > 512 "0.5" ifTrue:[
 		    pixel := pixel + 1.
 		    e := error - 1024 "1.0"
 		] ifFalse:[
 		    e := error
 		].
 		byte := byte bitOr:pixel.
 		e ~= 0 ifTrue:[
 		    e16 := e // 16.
 	    self colorsAtY:y from:0 to:(w-1) do:[:x :clr |
 		|e     "{ Class: SmallInteger }"
 		 pixel "{ Class: SmallInteger }"
 		 error "{ Class: SmallInteger }"
 		 e16   "{ Class: SmallInteger }"
 		 xE    "{ Class: SmallInteger }"
 		 xN    "{ Class: SmallInteger }" |
 		grey := (clr brightness * greyLevels).
 		pixel := grey truncated.
 		error := ((grey - pixel) * 1024) truncated.
 		xE := x + 2.
 		error := error + (errorArray at:xE).
 		byte := byte bitShift:depth.
 		error > 512 "0.5" ifTrue:[
 		    pixel := pixel + 1.
 		    e := error - 1024 "1.0"
 		] ifFalse:[
 		    e := error
 		].
 		byte := byte bitOr:pixel.
 		e ~= 0 ifTrue:[
 "Modified: 11.6.1996 / 00:13:38 / cg"
 !
 floydSteinbergDitheredMonochromeBits
 "return the bitmap for a dithered monochrome bitmap from the image.
 Works for any source depths / photometric,
 but very very slow since each pixel is processed individually.
 Redefined by some subclasses for more performance (D8Image)"
 |dstIndex        "{Class: SmallInteger }"
 nextDst         "{Class: SmallInteger }"
 nextErrorArray
 e eD t
 w               "{Class: SmallInteger }"
 h               "{Class: SmallInteger }"
 bitCnt          "{Class: SmallInteger }"
 byte            "{Class: SmallInteger }"
 grey
 eR eRB eB eLB |
 w := width.
 h := height.
 		int __eR, __eB, __eRB, __eLB, __eI;
 		int __bitCnt = __intVal(bitCnt);
 		__grey = __intVal(__ArrayInstPtr(greyValues)->a_element[__intVal(pixel)]);
 		__grey += __intVal(__errorArray[__x+1]);
 		__byte <<= 1;
 		if (__grey > 127*1024) {
 		    __e = __grey - (255*1024);
 		    __byte |= 1;
 		} else {
 		    __e = __grey;
 		}
 		if (__e) {
 		    __eI = __e >> 4;
 		    __eR  = __eI * 7;
 		    __eRB = __eI * 1;
 		    __eB  = __eI * 5;
 		    __eLB = __e - __eR - __eRB - __eB;
 		    __errorArray[__x+2] = __MKSMALLINT(__intVal(__errorArray[__x+2]) + __eR);
 		    __nextErrorArray[__x+2] = __MKSMALLINT(__intVal(__nextErrorArray[__x+2]) + __eRB);
 		    __nextErrorArray[__x+1] = __MKSMALLINT(__intVal(__nextErrorArray[__x+1]) + __eB);
 		    __nextErrorArray[__x  ] = __MKSMALLINT(__intVal(__nextErrorArray[__x  ]) + __eLB);
 		}
 		byte = __MKSMALLINT(__byte);
 		bitCnt = __MKSMALLINT(__bitCnt);
 %}.
 "/                |eI "{ Class: SmallInteger }"
 "/                 xE "{ Class: SmallInteger }"
 "/                 xN "{ Class: SmallInteger }" |
 "/
 "/                "/ get the colors grey value [0 .. 1]
 "/                grey := greyValues at:(pixel + 1).
 "/
 	    nextErrorArray := t.
 	    nextErrorArray atAllPut:0.
 	    self colorsAtY:y from:0 to:(w-1) do:[:x :clr |
 		|eI "{ Class: SmallInteger }"
 		 xE "{ Class: SmallInteger }"
 		 xN "{ Class: SmallInteger }" |
 		"/ get the colors grey value [0 .. 1]
 		grey := (clr brightness * 255).
 "Created: 8.6.1996 / 16:39:46 / cg"
 "Modified: 10.6.1996 / 15:12:11 / cg"
 !
 nearestPaintDepth8BitsColors:fixColors nRed:nRed nGreen:nGreen nBlue:nBlue
 "return a nearest paint bitmap from the receiver picture,
 which must be a depth-8 image.
 This is a special-cased dither method for 8-bit palette images being displayed on
 an 8-bit pseudoColor display, AND fixColor dithering is used.
 Use the colors in the fixColors array, which must be fixR x fixG x fixB
 colors assigned to aDevice, such as the preallocated colors of the
 Color class."
 |pseudoBits
 fixR    "{Class: SmallInteger }"
 fixG    "{Class: SmallInteger }"
 fixB    "{Class: SmallInteger }"
 fixGfixB
 r       "{Class: SmallInteger }"
 g       "{Class: SmallInteger }"
 b       "{Class: SmallInteger }"
 idx     "{Class: SmallInteger }"
 idMap lastColor
 clr|
 self depth ~~ 8 ifTrue:[^ nil].
 photometric == #palette ifTrue:[
 "Modified: 18.6.1996 / 09:18:09 / cg"
 !
 nfloydSteinbergDitheredDepth8BitsColors:colors
 "return a floyd-steinberg dithered bitmap from the receiver picture,
 which must be a depth-8 image.
 This method expects an array of colors to be used for dithering
 (which need not be a colorCubes colors)."
 |pseudoBits
 rgbBytes
 ditherRGBBytes ditherColors
 w       "{Class: SmallInteger }"
 h       "{Class: SmallInteger }"
 index   "{Class: SmallInteger }"
 numR    "{Class: SmallInteger }"
 dG  "{Class: SmallInteger }"
 dB  "{Class: SmallInteger }"
 iR    "{Class: SmallInteger }"
 iRG   "{Class: SmallInteger }"
 iRGB  "{Class: SmallInteger }"
 clr
 rI  "{Class: SmallInteger }"
 gI  "{Class: SmallInteger }"
 bI  "{Class: SmallInteger }"
 maxIDX  "{Class: SmallInteger }"
 subCubeColorCollection
 error
 dl "{Class: SmallInteger }"|
 self depth ~~ 8 ifTrue:[^ nil].
 "/
 "/    cube keysAndValuesDo:[:i :indices |
 "/        indices notNil ifTrue:[
 "/            nCube at:i put:(indices asByteArray)
 "/        ] ifFalse:[
 "/            "/ find nearest color
 "/
 "/            dl := 1.
 "/            [dl < maxBits] whileTrue:[
 "/                dR := dl negated.
 "/                [dR <= dl] whileTrue:[
 "/                    iR := i + (dR * shR).
 "/                    (iR > 0 and:[iR < maxIDX]) ifTrue:[
 "/                        dG := dl negated.
 "/                        [dG < dl] whileTrue:[
 "/                            iRG := iR + (dG * shG).
 "/                            (iRG > 0 and:[iRG < maxIDX]) ifTrue:[
 "/                                dB := dl negated.
 "/        ]
 "/    ].
 "/self halt.
 "/ now, cube contains collections of colors which are
 "/ positioned in a subCube; quickly accessed by a lookup
 pseudoBits := ByteArray uninitializedNew:(width * height).
 w := width.
 h := height.
 		int tR, tG, tB;
 		int nR, nG, nB;
 		int __dR, __dG, __dB;
 		int minDelta, bestIdx;
 		int __iR, __iG, __iB;
 		int cR, cG, cB;
 		int delta;
 		OBJ subCubeColors;
 		pix = *srcP++;
 #endif
 		} else {
 #ifdef REMEMBER_SEARCH
 		    if (__isSmallInteger(subCubeColors)) {
 			bestIdx = __intVal(subCubeColors);
 		    } else
 #endif
 		    {
 			bestIdx = __ByteArrayInstPtr(subCubeColors)->ba_element[0];
 		    }
 		}
 		/*
 		 * ok, now, we have found a collection of nearby
 		 * colors in subCubeColors.
 		 *
 		 * since the error is at most 1/16 (i.e. roughly 6%),
 		    __dB = dp[2];
 		}
 #endif
 /*
-printf("want: %d/%d/%d (%d/%d/%d) got: %d/%d/%d\n",
+console_printf("want: %d/%d/%d (%d/%d/%d) got: %d/%d/%d\n",
 		__wantR, __wantG, __wantB,
 		__wR, __wG, __wB,
 		__dR, __dG, __dB);
 */
 		/*
 #ifndef NO_FLOYD_STEINBERG
 		/*
 		 * the new error & distribute the error
 		 */
 		__eR = __wantR - __dR;
 		if (__eR) {
 		    tR = __eR >> 4;  /* 16th of error */
 		    nR = eP[3] + (tR * 7);/* from accu: error for (x+1 / y) */
 		    eP[0] = tR*5;         /* 5/16th for (x / y+1) */
 		    eP[-3] = tR*3;        /* 3/16th for (x-1 / y+1) */
 		} else {
 		    __eG = eP[4];
 		    eP[1] = eP[-2] = eP[4] = 0;
 		}
 		__eB = __wantB - __dB;
 		if (__eB) {
 		    tB = __eB >> 4;
 		    nB = eP[5] + (tB * 7);
 		    eP[2] = tB*5;
 		    eP[-1] = tB*3;
 !
 orderedDitheredGrayBitsWithDitherMatrix:ditherMatrix ditherWidth:dW depth:depth
 "return the bitmap for a dithered depth-bitmap from the image;
 with a constant ditherMatrix, this can be used for thresholding.
 Works for any source depths / photometric,
 but very very slow since each pixel is processed individually.
 Redefined by some subclasses for more performance (D8Image)"
 |dH nDither
 greyLevels greyValues greyPixels greyErrors
 dstIndex        "{Class: SmallInteger }"
 nextDst
 bytesPerOutRow  "{Class: SmallInteger }"
 pixelsPerByte   "{Class: SmallInteger }"
 outBits
 w               "{Class: SmallInteger }"
 h               "{Class: SmallInteger }"
 		__pixel = __greyPixels[__value];
 		__grey = __greyErrors[__value];
 		__dT = __ByteArrayInstPtr(ditherMatrix)
 			    ->ba_element[__intVal(x) % __dW
 					 + (__intVal(y) % __intVal(dH)) * __dW];
 		if (__grey > __dT) {
 		    __pixel++;
 		}
 	    byte := 0.
 	    bitCnt := 8.
 	    "/ this is the representaion independent (but slow)
 	    "/ inner loop - it extracts colors from the receiver
 	    self colorsAtY:y from:0 to:(w-1) do:[:x :clr |
 		|dstClr grey dT pixel|
 		"/ get the colors grey value [0 .. 1]
 		grey := clr brightness.
 		"/ remap into [0 .. greyLevels-1]
 		grey := grey * (greyLevels-1).
 		"/ get threshold pixel [0 .. greyLevels-1]
 		pixel := grey truncated.
 		"/ compute the error [0..1]
 		grey := grey - pixel.
 		"/ map into dither space [0 .. nDither]
 		int __dstIdx;
 		int __pixel;
 		int __bitCnt = __intVal(bitCnt);
 		__dT = __ByteArrayInstPtr(ditherMatrix)
 			    ->ba_element[__intVal(x) % __dW
 					 + (__intVal(y) % __intVal(dH)) * __dW];
 		__pixel = __intVal(pixel);
 		if (__intVal(grey) > __dT) {
 		    __pixel++;
 		}
 		__byte = (__byte << __intVal(depth)) | __pixel;
 		__bitCnt = __bitCnt - __intVal(depth);
 		if (__bitCnt == 0) {
 		    __dstIdx = __intVal(dstIndex);
 		    __ByteArrayInstPtr(outBits)->ba_element[__dstIdx-1] = __byte;
 		    __dstIdx = __dstIdx + 1;
 !
 orderedDitheredMonochromeBitsWithDitherMatrix:ditherMatrix ditherWidth:dW
 "return the bitmap for a dithered monochrome bitmap from the image;
 with a constant ditherMatrix, this can be used for thresholding.
 Works for any source depths / photometric,
 but very very slow since each pixel is processed individually.
 Redefined by some subclasses for more performance (D8Image)"
 |dH nDither
 greyValues
 dstIndex        "{Class: SmallInteger }"
 nextDst         "{Class: SmallInteger }"
 bytesPerMonoRow "{Class: SmallInteger }"
 monoBits
 		unsigned char *__greyValues = __ByteArrayInstPtr(greyValues)->ba_element;
 		__grey = __greyValues[__intVal(value)];
 		__dT = __ByteArrayInstPtr(ditherMatrix)
 			    ->ba_element[__intVal(x) % __dW
 					 + (__intVal(y) % __intVal(dH)) * __dW];
 		__byte = __byte << 1;
 		if (__grey > __dT) {
 		    __byte = __byte | 1;            /* white */
 		int __dT;
 		int __dstIdx;
 		int __bitCnt = __intVal(bitCnt);
 		__dT = __ByteArrayInstPtr(ditherMatrix)
 			    ->ba_element[__intVal(x) % __dW
 					 + (__intVal(y) % __intVal(dH)) * __dW];
 		__byte = __byte << 1;
 		if (__intVal(grey) > __dT) {
 		    __byte = __byte | 1;            /* white */
 		bitCnt = __MKSMALLINT(__bitCnt);
 %}.
 		0
 "/                dT := ditherMatrix at:(x \\ dW) + (y \\ dH * dW) + 1.
 "/
 "/                byte := byte bitShift:1.
 "/                grey < dT ifTrue:[
 "/                    byte := byte bitOr:1.
 "/                ].
 "/                bitCnt := bitCnt - 1.
 errorArray1 errorArray2 errorArray3
 e t
 w               "{Class: SmallInteger }"
 h               "{Class: SmallInteger }"
 bitCnt          "{Class: SmallInteger }"
 byte            "{Class: SmallInteger }"
 grey
 xE              "{Class: SmallInteger }" |
 self depth > 12 ifTrue:[
 	^ self floydSteinbergDitheredMonochromeBits
 "/ fetch scaled brightness values outside of loop into a table;
 "/ use table-value in loop
 greyValues := self greyMapForRange:(255 * 1024).
 0 to:(h-1) do:[:y |
 	nextDst := dstIndex + bytesPerMonoRow.
 	byte := 0.
 	bitCnt := 8.
 "draw a rectangle with some pixel value.
 By using #atImageAndMask:put: it also works on images with mono masks."
 |xI "{ Class: SmallInteger }"
 yI "{ Class: SmallInteger }"
 wI "{ Class: SmallInteger }"
 hI "{ Class: SmallInteger }"|
 xI := aRectangle left.
 yI := aRectangle top.
 wI := aRectangle width.
 "draw a rectangle with some pixel value.
 By using #atImageAndMask:put: it also works on images with mono masks."
 |xI "{ Class: SmallInteger }"
 yI "{ Class: SmallInteger }"
 wI "{ Class: SmallInteger }"
 hI "{ Class: SmallInteger }"|
 xI := aRectangle left.
 yI := aRectangle top.
 wI := aRectangle width.
 "fill a rectangular area with some pixel value.
 May be redefined in concrete subclasses for more performance, if req'd."
 |xI "{ Class: SmallInteger }"
 yI "{ Class: SmallInteger }"
 wI "{ Class: SmallInteger }"
 hI "{ Class: SmallInteger }"|
 xI := x.
 yI := y.
 wI := w.
 toDo idx pixel w h|
 w := self width.
 h := self height.
 surroundingPixelsOfDo :=
-[:pX :pY :fn |
+	[:pX :pY :fn |
-|nX nY|
+	    |nX nY|
-nX := pX + 1.
+	    nX := pX + 1.
-nY := pY + 1.
+	    nY := pY + 1.
-(nY < h) ifTrue: [fn value:pX value:nY].
+	    (nY < h) ifTrue: [fn value:pX value:nY].
-(pY > 0) ifTrue: [fn value:pX value:(pY - 1)].
+	    (pY > 0) ifTrue: [fn value:pX value:(pY - 1)].
-(nX < w) ifTrue: [fn value:nX value:pY].
+	    (nX < w) ifTrue: [fn value:nX value:pY].
-(pX > 0) ifTrue: [fn value:(pX - 1) value:pY].
+	    (pX > 0) ifTrue: [fn value:(pX - 1) value:pY].
-].
+	].
 enumerateDetectedPixelsAndDo :=
-[:detectedPixels :action |
+	[:detectedPixels :action |
-|idx|
+	    |idx|
-idx := 1.
+	    idx := 1.
-0 to:h-1 do:[:y |
+	    0 to:h-1 do:[:y |
-0 to:w-1 do:[:x |
+		0 to:w-1 do:[:x |
-(detectedPixels at:idx) ifTrue:[
+		    (detectedPixels at:idx) ifTrue:[
-action value:x value:y
+			action value:x value:y
-].
+		    ].
-idx := idx + 1.
+		    idx := idx + 1.
-].
+		].
-].
+	    ].
-].
+	].
 processPixelToFill := [:spX :spY |
-|sp idx|
+	    |sp idx|
-((self pixelAtX:spX y:spY) == detectedPixel and: [mask isNil or:[(mask pixelAtX:spX y:spY) == 1]])
+	    ((self pixelAtX:spX y:spY) == detectedPixel and: [mask isNil or:[(mask pixelAtX:spX y:spY) == 1]])
-ifTrue: [
+	    ifTrue: [
-idx := 1 + spX + (spY * w).
+		idx := 1 + spX + (spY * w).
-(allDetectedPixelCoordinates at:idx) ifFalse:[
+		(allDetectedPixelCoordinates at:idx) ifFalse:[
-allDetectedPixelCoordinates at:idx put:true.
+		    allDetectedPixelCoordinates at:idx put:true.
-toDo add:spX @ spY.
+		    toDo add:spX @ spY.
-].
+		].
-]
+	    ]
-].
+	].
 (mask notNil and: [(mask pixelAt:aPoint) == 0]) ifTrue:[
-allDetectedPixelCoordinates := mask floodFillAt: aPoint withColor: Color white.
+	allDetectedPixelCoordinates := mask floodFillAt: aPoint withColor: Color white.
-enumerateDetectedPixelsAndDo
+	enumerateDetectedPixelsAndDo
-value:allDetectedPixelCoordinates
+		value:allDetectedPixelCoordinates
-value:[:x :y | self atImageAndMask:(x@y) put: aColor].
+		value:[:x :y | self atImageAndMask:(x@y) put: aColor].
-^ allDetectedPixelCoordinates
+	^ allDetectedPixelCoordinates
 ].
 detectedPixel := self pixelAt: aPoint.
 allDetectedPixelCoordinates := BooleanArray new:(w * h).
 toDo := OrderedCollection new:1000.
 allDetectedPixelCoordinates at:(1 + aPoint x + (aPoint y * w)) put:true.
 toDo add:aPoint.
 [toDo notEmpty] whileTrue:[
-|p|
+	|p|
-p := toDo removeFirst.
+	p := toDo removeFirst.
-surroundingPixelsOfDo value:p x value:p y value:processPixelToFill.
+	surroundingPixelsOfDo value:p x value:p y value:processPixelToFill.
 ].
 idx := 1.
 aColor redByte notNil ifTrue:[
-pixel := self valueFromColor:aColor.
+	pixel := self valueFromColor:aColor.
 ].
 pixel isNil ifTrue:[
-enumerateDetectedPixelsAndDo
+	enumerateDetectedPixelsAndDo
-value:allDetectedPixelCoordinates
+		value:allDetectedPixelCoordinates
-value:[:x :y | mask pixelAtX:x y:y put:0].
+		value:[:x :y | mask pixelAtX:x y:y put:0].
 ] ifFalse:[
-enumerateDetectedPixelsAndDo
+	enumerateDetectedPixelsAndDo
-value:allDetectedPixelCoordinates
+		value:allDetectedPixelCoordinates
-value:[:x :y | self pixelAtX:x y:y put:pixel].
+		value:[:x :y | self pixelAtX:x y:y put:pixel].
 ].
 ^ allDetectedPixelCoordinates
 "Modified: / 29.7.1998 / 03:09:16 / cg"
 !
 yR|
 yS := yStart.
 yE := yEnd.
 yS to:yE do:[:yRun |
 	yR := yRun.
 	self colorsAtY:yRun from:xStart to:xEnd do:[:xRun :color |
 	    aBlock value:xRun value:yR value:color
 	]
 ]
 "Modified: 11.7.1996 / 19:50:47 / cg"
 !
 "Modified: 7.6.1996 / 19:11:06 / cg"
 !
 valuesAtY:y from:x1 to:x2 do:aBlock
 "WARNING: for now, this enumerates pixel values
 (backward compatibility with ST/X)
 In the future, this will enumerate colors
 Use #pixelAtT:from:to:do: - for future compatibility.
 perform aBlock for each pixelValue from x1 to x2 in row y.
 Notice, that x and y coordinates start at 0@0 for the upper left corner.
 The block is passed the x coordinate and the pixelValue at each pixel.
 |xS "{Class: SmallInteger }"
 xE "{Class: SmallInteger }"|
 xS := xStart.
 xE := xEnd.
 yStart to:yEnd do:[:yRun |
 	self valuesAtY:yRun from:xStart to:xEnd do:[:xRun :pixel |
 	    aBlock value:xRun value:yRun value:pixel
 	]
 ]
 "some Image has been collected - nothing to do"
 ! !
 !Image methodsFor:'image manipulations'!
 applyPixelValuesTo:pixelFunctionBlock in:aRectangle into:newImage
 "helper for withPixelFunctionAppliedToValues:
 enumerate pixelValues and evaluate the block for each.
 Could be redefined by subclasses for better performance."
 |w   "{Class: SmallInteger }"
 applyPixelValuesTo:pixelFunctionBlock into:newImage
 "helper for withPixelFunctionAppliedToValues:
 enumerate pixelValues and evaluate the block for each."
 ^ self
 	applyPixelValuesTo:pixelFunctionBlock
 	in:(0@0 corner:width@height)
 	into:newImage
 !
 blendWith:aColor
 "return a new image which is blended with some color.
 The receiver must be a palette image (currently).
 CAVEAT: this only works with palette images (i.e. not for rgb or greyScale).
 CAVEAT: Need an argument, which specifies by how much it should be lighter."
 ^ self
 	copyWithColorMapProcessing:[:clr | clr blendWith:aColor]
 "
 (Smalltalk bitmapFromFileNamed:'gifImages/claus.gif' inPackage:'stx:goodies') inspect
 ((Smalltalk bitmapFromFileNamed:'gifImages/claus.gif' inPackage:'stx:goodies') blendWith:Color red) inspect
 "Modified: 24.4.1997 / 18:31:23 / cg"
 !
 colorMapProcessing:aBlock
 "a helper for all kinds of colormap manipulations.
 The argument, aBlock is called for every colormap entry,
 and the returned value will replace the original entry in the map.
 This will fail for non-palette images.
 See examples in Image>>copyWithColorMapProcessing:"
 |nColors "{ Class: SmallInteger }"|
 CAVEAT: this only works with palette images (i.e. not for rgb or greyScale)"
 |newImage|
 self colorMap isNil ifTrue:[
-^ self withPixelFunctionApplied:[:orig :clr :x :y | aBlock  value:clr]
+	^ self withPixelFunctionApplied:[:orig :clr :x :y | aBlock  value:clr]
 "/        self error:'no colormap in image'.
 "/        ^ nil
 ].
 "
 ^ newImage
 "
 leave red component only:
 (Image fromFile:'goodies/bitmaps/gifImages/claus.gif')
-copyWithColorMapProcessing:[:clr | Color red:(clr red) green:0 blue:0]
+	copyWithColorMapProcessing:[:clr | Color red:(clr red) green:0 blue:0]
 "
 "
 make it reddish:
 (Image fromFile:'bitmaps/gifImages/claus.gif')
-copyWithColorMapProcessing:[:clr | Color red:((clr red * 2) min:100) green:clr green blue:clr blue]
+	copyWithColorMapProcessing:[:clr | Color red:((clr red * 2) min:100) green:clr green blue:clr blue]
 "
 "
 invert:
 (Image fromFile:'bitmaps/gifImages/claus.gif')
-copyWithColorMapProcessing:[:clr | Color red:(100 - clr red) green:(100 - clr green) blue:(100 - clr green)]
+	copyWithColorMapProcessing:[:clr | Color red:(100 - clr red) green:(100 - clr green) blue:(100 - clr green)]
 "
 "
 lighter:
 (Image fromFile:'bitmaps/gifImages/claus.gif')
-copyWithColorMapProcessing:[:clr | |r g b|
+	copyWithColorMapProcessing:[:clr | |r g b|
-r := clr red.  g := clr green.  b := clr blue.
+						r := clr red.  g := clr green.  b := clr blue.
-Color red:(r + (100-r//2))
+						Color red:(r + (100-r//2))
-green:(g + (100-g//2))
+						      green:(g + (100-g//2))
-blue:(b + (100-b//2))]
+						      blue:(b + (100-b//2))]
 "
 "
 darker:
 (Image fromFile:'bitmaps/gifImages/claus.gif')
-copyWithColorMapProcessing:[:clr | Color red:(clr red//2) green:(clr green // 2) blue:(clr blue // 2)]
+	copyWithColorMapProcessing:[:clr | Color red:(clr red//2) green:(clr green // 2) blue:(clr blue // 2)]
 "
 "Modified: 24.4.1997 / 18:28:05 / cg"
 !
 "return a new image which is slightly darker than the receiver.
 The receiver must be a palette image (currently).
 CAVEAT: this only works with palette images (i.e. not for rgb or greyScale).
 CAVEAT: Need an argument, which specifies by how much it should be darker."
 ^ self
 	copyWithColorMapProcessing:[:clr | clr darkened]
 "
 (Smalltalk bitmapFromFileNamed:'gifImages/claus.gif' inPackage:'stx:goodies') inspect
 (Smalltalk bitmapFromFileNamed:'gifImages/claus.gif' inPackage:'stx:goodies') darkened inspect
 flipVertical
 "inplace vertical flip"
 |h           "{Class: SmallInteger }"
 bytesPerRow "{Class: SmallInteger }"
 buffer
 indexLow    "{Class: SmallInteger }"
 indexHi     "{Class: SmallInteger }"
 bytes|
 bytes := self bits.
 hardMagnifiedBy:scalePoint
 "return a new image magnified by scalePoint, aPoint.
 This is the general magnification method, handling non-integral values.
 It is slower than the integral magnification method."
 |mX
 mY
 newWidth  "{ Class: SmallInteger }"
 newHeight "{ Class: SmallInteger }"
 w         "{ Class: SmallInteger }"
 h         "{ Class: SmallInteger }"
 newImage newBits bitsPerPixel newBytesPerRow newMask
 value
 srcRow pixelArray|
 mX := scalePoint x.
 mY := scalePoint y.
 ((mX < 0) or:[mY < 0]) ifTrue:[^ nil].
 mask notNil ifTrue:[
 	newMask := (mask magnifiedBy:scalePoint)
 ].
 newImage := self species new.
 newImage
 	width:newWidth
 	height:newHeight
 	photometric:photometric
 	samplesPerPixel:samplesPerPixel
 	bitsPerSample:bitsPerSample
 	colorMap:colorMap copy
 	bits:newBits
 	mask:newMask.
 "walk over destination image fetching pixels from source image"
 "Modified: 24.4.1997 / 18:30:24 / cg"
 !
 hardRotated:degrees
 "return a new image from the old one, by rotating the image
 degrees clockwise.
 Warning: the returned image will be larger than the original image."
 |p r a aN p1 p2 p3 p4 maxX minX maxY minY
 newImage
 newWidth  "{ Class: SmallInteger }"
 newHeight "{ Class: SmallInteger }"
 newBytesPerRow newBits
 blackPixel halfW halfH radians m t bad
 bytesPerRow myDepth maskBits
 pX pY srcX srcY pix nX nY
 sinRot cosRot sinPY cosPY|
 radians := degrees degreesToRadians.
 "/ placing the image at the origin,
 p := (width - 1 / 2) @ (height - 1 / 2).
 r := p r.
 a := p theta.
 "/ add the rotation
 "/ (sight - subtract, we defined things clockwise ...
 "/  ... in contrast to point which thinks counter-clockwise)
 aN := a - radians.
 "/ compute new corner points
 "/ compute the boundary of the new image
 maxX := minX := p1 x.
 (t := p2 x) > maxX ifTrue:[
-maxX := t
+	maxX := t
 ] ifFalse:[
-t < minX ifTrue:[minX := t].
+	t < minX ifTrue:[minX := t].
 ].
 (t := p3 x) > maxX ifTrue:[
-maxX := t
+	maxX := t
 ] ifFalse:[
-t < minX ifTrue:[minX := t].
+	t < minX ifTrue:[minX := t].
 ].
 (t := p4 x) > maxX ifTrue:[
-maxX := t
+	maxX := t
 ] ifFalse:[
-t < minX ifTrue:[minX := t].
+	t < minX ifTrue:[minX := t].
 ].
 maxY := minY := p1 y.
 (t := p2 y) > maxY ifTrue:[
-maxY := t
+	maxY := t
 ] ifFalse:[
-t < minY ifTrue:[minY := t].
+	t < minY ifTrue:[minY := t].
 ].
 (t := p3 y) > maxY ifTrue:[
-maxY := t
+	maxY := t
 ] ifFalse:[
-t < minY ifTrue:[minY := t].
+	t < minY ifTrue:[minY := t].
 ].
 (t := p4 y) > maxY ifTrue:[
-maxY := t
+	maxY := t
 ] ifFalse:[
-t < minY ifTrue:[minY := t].
+	t < minY ifTrue:[minY := t].
 ].
 newWidth := (maxX - minX) rounded + 1.
 newHeight := (maxY - minY) rounded + 1.
 newImage samplesPerPixel:samplesPerPixel.
 newImage bitsPerSample:bitsPerSample.
 newImage colorMap:colorMap copy.
 newImage maskedPixelsAre0:maskedPixelsAre0.
 mask notNil ifTrue:[
-newImage mask:(mask rotated:degrees)
+	newImage mask:(mask rotated:degrees)
 ] ifFalse:[
-self isMask ifFalse:[
+	self isMask ifFalse:[
-self depth ~~ 1 ifTrue:[
+	    self depth ~~ 1 ifTrue:[
-m := ImageMask width:width height:height.
+		m := ImageMask width:width height:height.
-m bits:(maskBits := ByteArray new:(m bytesPerRow * height)).
+		m bits:(maskBits := ByteArray new:(m bytesPerRow * height)).
-maskBits atAllPut:16rFF.
+		maskBits atAllPut:16rFF.
-newImage mask:(m rotated:degrees)
+		newImage mask:(m rotated:degrees)
-]
+	    ]
-]
+	]
 ].
 maskedPixelsAre0 ifTrue:[
-blackPixel := 0.
+	blackPixel := 0.
 ] ifFalse:[
-blackPixel := self valueFromColor:Color black.
+	blackPixel := self valueFromColor:Color black.
-blackPixel isNil ifTrue:[
+	blackPixel isNil ifTrue:[
-blackPixel := self valueFromColor:Color white.
+	    blackPixel := self valueFromColor:Color white.
-blackPixel isNil ifTrue:[
+	    blackPixel isNil ifTrue:[
-blackPixel := 0.
+		blackPixel := 0.
-]
+	    ]
-]
+	]
 ].
 self isMask ifTrue:[
-blackPixel := 0.
+	blackPixel := 0.
 ].
 myDepth := self depth.
 newBits atAllPut:0.
 "/ now, walk over destination pixels,
 "/ fetching from source.
 "/ (if we walked over the source, we could get holes
 "/  in the destination image ...)
 halfW := (width - 1) / 2.0.
 halfH := (height - 1) / 2.0.
 double sin(), cos();
 #   define Float_PI 3.14159
 bad = true;
 if (1
 && __isFloat(minX)
 && __isFloat(minY)
 && __isFloat(radians)
 && __isFloat(halfW)
 && __isFloat(halfH)
 && __isByteArray(newBits)
 && __isByteArray(__INST(bytes))) {
-__srcBytes = __ByteArrayInstPtr(__INST(bytes))->ba_element;
+	__srcBytes = __ByteArrayInstPtr(__INST(bytes))->ba_element;
-__dstBytes = __ByteArrayInstPtr(newBits)->ba_element;
+	__dstBytes = __ByteArrayInstPtr(newBits)->ba_element;
-__nSrcBytes = __byteArraySize(__INST(bytes));
+	__nSrcBytes = __byteArraySize(__INST(bytes));
-__nDstBytes = __byteArraySize(newBits);
+	__nDstBytes = __byteArraySize(newBits);
-__blackPixel = __intVal(blackPixel);
+	__blackPixel = __intVal(blackPixel);
-__radians = __floatVal(radians);
+	__radians = __floatVal(radians);
-__radians = -__radians; /* sigh: clock-wise */
+	__radians = -__radians; /* sigh: clock-wise */
-__sin = sin(__radians);
+	__sin = sin(__radians);
-__cos = cos(__radians);
+	__cos = cos(__radians);
-__minX = __floatVal(minX);
+	__minX = __floatVal(minX);
-__minY = __floatVal(minY);
+	__minY = __floatVal(minY);
-__halfW = __floatVal(halfW);
+	__halfW = __floatVal(halfW);
-__halfH = __floatVal(halfH);
+	__halfH = __floatVal(halfH);
-__dstRowPtr = __dstBytes;
+	__dstRowPtr = __dstBytes;
-__dstEndPtr = __dstBytes + __nDstBytes;
+	__dstEndPtr = __dstBytes + __nDstBytes;
 #       define EARLY_OUT
 #       define FAST_ADVANCE 5
 #       define FAST_ADVANCE2
-switch (__depth) {
+	switch (__depth) {
-case 8:
+	    case 8:
-for (__dstY = 0; __dstY < __newHeight; __dstY++) {
+		for (__dstY = 0; __dstY < __newHeight; __dstY++) {
-double __pY, __sinPY, __cosPY;
+		    double __pY, __sinPY, __cosPY;
 #ifdef EARLY_OUT
-int didFetchInRow = 0;
+		    int didFetchInRow = 0;
 #endif
-__pY = (double)(__dstY + __minY);
+		    __pY = (double)(__dstY + __minY);
-__sinPY = __sin * __pY;
+		    __sinPY = __sin * __pY;
-__cosPY = __cos * __pY;
+		    __cosPY = __cos * __pY;
-__dstPtr = __dstRowPtr;
+		    __dstPtr = __dstRowPtr;
-__dstRowPtr += __dstBytesPerRow;
+		    __dstRowPtr += __dstBytesPerRow;
-for (__dstX = 0; __dstX < __newWidth; __dstX++) {
+		    for (__dstX = 0; __dstX < __newWidth; __dstX++) {
-double __pX, __nX;
+			double __pX, __nX;
-unsigned __pix;
+			unsigned __pix;
-/* translate X in destination (center to 0/0) */
+			/* translate X in destination (center to 0/0) */
-__pX = (double)(__dstX + __minX);
+			__pX = (double)(__dstX + __minX);
-/* rotate X */
+			/* rotate X */
-__nX = (__cos * __pX) - __sinPY;
+			__nX = (__cos * __pX) - __sinPY;
-/* translate X in source (origin to 0/0) */
+			/* translate X in source (origin to 0/0) */
-__nX = __nX + __halfW + 0.5;
+			__nX = __nX + __halfW + 0.5;
-/* inside ? */
+			/* inside ? */
-if (__nX < 0) {
+			if (__nX < 0) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+			    if (didFetchInRow) {
-break;
+				break;
-}
+			    }
 #endif
 #ifdef FAST_ADVANCE
-if (__blackPixel == 0) {
+			    if (__blackPixel == 0) {
-do {
+				do {
-/* try advance by FAST_ADVANCE pixels ... */
+				    /* try advance by FAST_ADVANCE pixels ... */
-__dstX += FAST_ADVANCE; __dstPtr += FAST_ADVANCE;
+				    __dstX += FAST_ADVANCE; __dstPtr += FAST_ADVANCE;
-if (__dstX >= __newWidth) {
+				    if (__dstX >= __newWidth) {
-break;
+					break;
-}
+				    }
-__pX = (double)(__dstX + __minX);
+				    __pX = (double)(__dstX + __minX);
-__nX = (__cos * __pX) - __sinPY;
+				    __nX = (__cos * __pX) - __sinPY;
-__nX = __nX + __halfW + 0.5;
+				    __nX = __nX + __halfW + 0.5;
-} while (__nX < 0);
+				} while (__nX < 0);
-__dstX -= FAST_ADVANCE; __dstPtr -= FAST_ADVANCE;
+				__dstX -= FAST_ADVANCE; __dstPtr -= FAST_ADVANCE;
-}
+			    }
 #endif
-__pix = __blackPixel;
+			    __pix = __blackPixel;
-} else {
+			} else {
-int __srcX;
+			    int __srcX;
-__srcX = (int)__nX;
+			    __srcX = (int)__nX;
-/* inside ? */
+			    /* inside ? */
-if (__srcX >= __width) {
+			    if (__srcX >= __width) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+				if (didFetchInRow) {
-break;
+				    break;
-}
+				}
 #endif
 #ifdef FAST_ADVANCE2
-if (__blackPixel == 0) {
+				if (__blackPixel == 0) {
-do {
+				    do {
-/* try advance by FAST_ADVANCE pixels ... */
+					/* try advance by FAST_ADVANCE pixels ... */
-__dstX += FAST_ADVANCE; __dstPtr += FAST_ADVANCE;
+					__dstX += FAST_ADVANCE; __dstPtr += FAST_ADVANCE;
-if (__dstX >= __newWidth) {
+					if (__dstX >= __newWidth) {
-break;
+					    break;
-}
+					}
-__pX = (double)(__dstX + __minX);
+					__pX = (double)(__dstX + __minX);
-__nX = (__cos * __pX) - __sinPY;
+					__nX = (__cos * __pX) - __sinPY;
-__nX = __nX + __halfW + 0.5;
+					__nX = __nX + __halfW + 0.5;
-__srcX = (int)__nX;
+					__srcX = (int)__nX;
-} while (__srcX >= __width);
+				    } while (__srcX >= __width);
-__dstX -= FAST_ADVANCE; __dstPtr -= FAST_ADVANCE;
+				    __dstX -= FAST_ADVANCE; __dstPtr -= FAST_ADVANCE;
-}
+				}
 #endif
-__pix = __blackPixel;
+				__pix = __blackPixel;
-} else {
+			    } else {
-double __nY;
+				double __nY;
-/* rotate Y */
+				/* rotate Y */
-__nY = (__sin * __pX) + __cosPY;
+				__nY = (__sin * __pX) + __cosPY;
-/* translate Y in source (origin to 0/0) */
+				/* translate Y in source (origin to 0/0) */
-__nY = __nY + __halfH + 0.5;
+				__nY = __nY + __halfH + 0.5;
-/* inside ? */
+				/* inside ? */
-if (__nY < 0) {
+				if (__nY < 0) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+				    if (didFetchInRow) {
-break;
+					break;
-}
+				    }
 #endif
 #ifdef FAST_ADVANCE2
-if (__blackPixel == 0) {
+				    if (__blackPixel == 0) {
-do {
+					do {
-/* try advance by FAST_ADVANCE pixels ... */
+					    /* try advance by FAST_ADVANCE pixels ... */
-__dstX += FAST_ADVANCE; __dstPtr += FAST_ADVANCE;
+					    __dstX += FAST_ADVANCE; __dstPtr += FAST_ADVANCE;
-if (__dstX >= __newWidth) {
+					    if (__dstX >= __newWidth) {
-break;
+						break;
-}
+					    }
-__pX = (double)(__dstX + __minX);
+					    __pX = (double)(__dstX + __minX);
-__nY = (__sin * __pX) + __cosPY;
+					    __nY = (__sin * __pX) + __cosPY;
-__nY = __nY + __halfH + 0.5;
+					    __nY = __nY + __halfH + 0.5;
-} while (__nY < 0);
+					} while (__nY < 0);
-__dstX -= FAST_ADVANCE; __dstPtr -= FAST_ADVANCE;
+					__dstX -= FAST_ADVANCE; __dstPtr -= FAST_ADVANCE;
-}
+				    }
 #endif
-__pix = __blackPixel;
+				    __pix = __blackPixel;
-} else {
+				} else {
-int __srcY;
+				    int __srcY;
-__srcY = (int)__nY;
+				    __srcY = (int)__nY;
-/* inside ? */
+				    /* inside ? */
-if (__srcY >= __height) {
+				    if (__srcY >= __height) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+					if (didFetchInRow) {
-break;
+					    break;
-}
+					}
 #endif
 #ifdef FAST_ADVANCE
-if (__blackPixel == 0) {
+					if (__blackPixel == 0) {
-do {
+					    do {
-/* try advance by FAST_ADVANCE pixels ... */
+						/* try advance by FAST_ADVANCE pixels ... */
-__dstX += FAST_ADVANCE; __dstPtr += FAST_ADVANCE;
+						__dstX += FAST_ADVANCE; __dstPtr += FAST_ADVANCE;
-if (__dstX >= __newWidth) {
+						if (__dstX >= __newWidth) {
-break;
+						    break;
-}
+						}
-__pX = (double)(__dstX + __minX);
+						__pX = (double)(__dstX + __minX);
-__nY = (__sin * __pX) + __cosPY;
+						__nY = (__sin * __pX) + __cosPY;
-__nY = __nY + __halfH + 0.5;
+						__nY = __nY + __halfH + 0.5;
-__srcY = (int)__nY;
+						__srcY = (int)__nY;
-} while (__srcY >= __height);
+					    } while (__srcY >= __height);
-__dstX -= FAST_ADVANCE; __dstPtr -= FAST_ADVANCE;
+					    __dstX -= FAST_ADVANCE; __dstPtr -= FAST_ADVANCE;
-}
+					}
 #endif
-__pix = __blackPixel;
+					__pix = __blackPixel;
-} else {
+				    } else {
-/* fetch source pixel */
+					/* fetch source pixel */
-int idx;
+					int idx;
 #ifdef EARLY_OUT
-didFetchInRow = 1;
+					didFetchInRow = 1;
 #endif
-idx = __srcY * __srcBytesPerRow + __srcX;
+					idx = __srcY * __srcBytesPerRow + __srcX;
-if ((unsigned)idx < __nSrcBytes) {
+					if ((unsigned)idx < __nSrcBytes) {
-__pix = __srcBytes[idx];
+					    __pix = __srcBytes[idx];
-} else {
+					} else {
-__pix = __blackPixel;
+					    __pix = __blackPixel;
-}
+					}
-}
+				    }
-}
+				}
-}
+			    }
-}
+			}
-if (__pix != 0) {
+			if (__pix != 0) {
-*__dstPtr = __pix;
+			    *__dstPtr = __pix;
-}
+			}
-__dstPtr++;
+			__dstPtr++;
-}
+		    }
-}
+		}
-break;
+		break;
-case 1:
+	    case 1:
-for (__dstY = 0; __dstY < __newHeight; __dstY++) {
+		for (__dstY = 0; __dstY < __newHeight; __dstY++) {
-double __pY, __sinPY, __cosPY;
+		    double __pY, __sinPY, __cosPY;
 #ifdef EARLY_OUT
-int didFetchInRow = 0;
+		    int didFetchInRow = 0;
 #endif
-__pY = (double)(__dstY + __minY);
+		    __pY = (double)(__dstY + __minY);
-__sinPY = __sin * __pY;
+		    __sinPY = __sin * __pY;
-__cosPY = __cos * __pY;
+		    __cosPY = __cos * __pY;
-__dstPtr = __dstRowPtr;
+		    __dstPtr = __dstRowPtr;
-__dstMask = 0x80;
+		    __dstMask = 0x80;
-__dstRowPtr += __dstBytesPerRow;
+		    __dstRowPtr += __dstBytesPerRow;
-for (__dstX = 0; __dstX < __newWidth; __dstX++) {
+		    for (__dstX = 0; __dstX < __newWidth; __dstX++) {
-double __pX, __nX;
+			double __pX, __nX;
-int __pix;
+			int __pix;
-/* translate X in destination (center to 0/0) */
+			/* translate X in destination (center to 0/0) */
-__pX = (double)(__dstX + __minX);
+			__pX = (double)(__dstX + __minX);
-/* rotate X */
+			/* rotate X */
-__nX = (__cos * __pX) - __sinPY;
+			__nX = (__cos * __pX) - __sinPY;
-/* translate X in source (origin to 0/0) */
+			/* translate X in source (origin to 0/0) */
-__nX = __nX + __halfW + 0.5;
+			__nX = __nX + __halfW + 0.5;
-/* inside ? */
+			/* inside ? */
-if (__nX < 0) {
+			if (__nX < 0) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+			    if (didFetchInRow) {
-break;
+				break;
-}
+			    }
 #endif
 #ifdef FAST_ADVANCE
-if (__blackPixel == 0) {
+			    if (__blackPixel == 0) {
-do {
+				do {
-/* try advance by 8 pixels ... */
+				    /* try advance by 8 pixels ... */
-__dstX += 8; __dstPtr ++;
+				    __dstX += 8; __dstPtr ++;
-if (__dstX >= __newWidth) {
+				    if (__dstX >= __newWidth) {
-break;
+					break;
-}
+				    }
-__pX = (double)(__dstX + __minX);
+				    __pX = (double)(__dstX + __minX);
-__nX = (__cos * __pX) - __sinPY;
+				    __nX = (__cos * __pX) - __sinPY;
-__nX = __nX + __halfW + 0.5;
+				    __nX = __nX + __halfW + 0.5;
-} while (__nX < 0);
+				} while (__nX < 0);
-__dstX -= 8; __dstPtr--;
+				__dstX -= 8; __dstPtr--;
-}
+			    }
 #endif
-__pix = __blackPixel;
+			    __pix = __blackPixel;
-} else {
+			} else {
-int __srcX;
+			    int __srcX;
-__srcX = (int)__nX;
+			    __srcX = (int)__nX;
-/* inside ? */
+			    /* inside ? */
-if (__srcX >= __width) {
+			    if (__srcX >= __width) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+				if (didFetchInRow) {
-break;
+				    break;
-}
+				}
 #endif
 #ifdef FAST_ADVANCE2
-if (__blackPixel == 0) {
+				if (__blackPixel == 0) {
-do {
+				    do {
-/* try advance by 8 pixels ... */
+					/* try advance by 8 pixels ... */
-__dstX += 8; __dstPtr++;
+					__dstX += 8; __dstPtr++;
-if (__dstX >= __newWidth) {
+					if (__dstX >= __newWidth) {
-break;
+					    break;
-}
+					}
-__pX = (double)(__dstX + __minX);
+					__pX = (double)(__dstX + __minX);
-__nX = (__cos * __pX) - __sinPY;
+					__nX = (__cos * __pX) - __sinPY;
-__nX = __nX + __halfW + 0.5;
+					__nX = __nX + __halfW + 0.5;
-__srcX = (int)__nX;
+					__srcX = (int)__nX;
-} while (__srcX >= __width);
+				    } while (__srcX >= __width);
-__dstX -= 8; __dstPtr--;
+				    __dstX -= 8; __dstPtr--;
-}
+				}
 #endif
-__pix = __blackPixel;
+				__pix = __blackPixel;
-} else {
+			    } else {
-double __nY;
+				double __nY;
-/* rotate Y */
+				/* rotate Y */
-__nY = (__sin * __pX) + __cosPY;
+				__nY = (__sin * __pX) + __cosPY;
-/* translate Y in source (origin to 0/0) */
+				/* translate Y in source (origin to 0/0) */
-__nY = __nY + __halfH + 0.5;
+				__nY = __nY + __halfH + 0.5;
-/* inside ? */
+				/* inside ? */
-if (__nY < 0) {
+				if (__nY < 0) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+				    if (didFetchInRow) {
-break;
+					break;
-}
+				    }
 #endif
 #ifdef FAST_ADVANCE2
-if (__blackPixel == 0) {
+				    if (__blackPixel == 0) {
-do {
+					do {
-/* try advance by 8 pixels ... */
+					    /* try advance by 8 pixels ... */
-__dstX += 8; __dstPtr++;
+					    __dstX += 8; __dstPtr++;
-if (__dstX >= __newWidth) {
+					    if (__dstX >= __newWidth) {
-break;
+						break;
-}
+					    }
-__pX = (double)(__dstX + __minX);
+					    __pX = (double)(__dstX + __minX);
-__nY = (__sin * __pX) + __cosPY;
+					    __nY = (__sin * __pX) + __cosPY;
-__nY = __nY + __halfH + 0.5;
+					    __nY = __nY + __halfH + 0.5;
-} while (__nY < 0);
+					} while (__nY < 0);
-__dstX -= 8; __dstPtr--;
+					__dstX -= 8; __dstPtr--;
-}
+				    }
 #endif
-__pix = __blackPixel;
+				    __pix = __blackPixel;
-} else {
+				} else {
-int __srcY;
+				    int __srcY;
-__srcY = (int)__nY;
+				    __srcY = (int)__nY;
-/* inside ? */
+				    /* inside ? */
-if (__srcY >= __height) {
+				    if (__srcY >= __height) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+					if (didFetchInRow) {
-break;
+					    break;
-}
+					}
 #endif
 #ifdef FAST_ADVANCE
-if (__blackPixel == 0) {
+					if (__blackPixel == 0) {
-do {
+					    do {
-/* try advance by 8 pixels ... */
+						/* try advance by 8 pixels ... */
-__dstX += 8; __dstPtr++;
+						__dstX += 8; __dstPtr++;
-if (__dstX >= __newWidth) {
+						if (__dstX >= __newWidth) {
-break;
+						    break;
-}
+						}
-__pX = (double)(__dstX + __minX);
+						__pX = (double)(__dstX + __minX);
-__nY = (__sin * __pX) + __cosPY;
+						__nY = (__sin * __pX) + __cosPY;
-__nY = __nY + __halfH + 0.5;
+						__nY = __nY + __halfH + 0.5;
-__srcY = (int)__nY;
+						__srcY = (int)__nY;
-} while (__srcY >= __height);
+					    } while (__srcY >= __height);
-__dstX -= 8; __dstPtr--;
+					    __dstX -= 8; __dstPtr--;
-}
+					}
 #endif
-__pix = __blackPixel;
+					__pix = __blackPixel;
-} else {
+				    } else {
-/* fetch source pixel */
+					/* fetch source pixel */
-int idx, pV;
+					int idx, pV;
 #ifdef EARLY_OUT
-didFetchInRow = 1;
+					didFetchInRow = 1;
 #endif
-idx = __srcY * __srcBytesPerRow + (__srcX >> 3);
+					idx = __srcY * __srcBytesPerRow + (__srcX >> 3);
-if ((unsigned)idx < __nSrcBytes) {
+					if ((unsigned)idx < __nSrcBytes) {
-pV = __srcBytes[idx];
+					    pV = __srcBytes[idx];
-__pix = (pV & (0x80 >> (__srcX & 7))) ? 1 : 0;
+					    __pix = (pV & (0x80 >> (__srcX & 7))) ? 1 : 0;
-} else {
+					} else {
-__pix = __blackPixel;
+					    __pix = __blackPixel;
-}
+					}
-}
+				    }
-}
+				}
-}
+			    }
-}
+			}
-/* store pixel */
+			/* store pixel */
-if (__pix != 0) {
+			if (__pix != 0) {
-*__dstPtr |= __dstMask;
+			    *__dstPtr |= __dstMask;
-}
+			}
-__dstMask >>= 1;
+			__dstMask >>= 1;
-if (__dstMask == 0) {
+			if (__dstMask == 0) {
-__dstMask = 0x80;
+			    __dstMask = 0x80;
-__dstPtr++;
+			    __dstPtr++;
-}
+			}
-}
+		    }
-}
+		}
-break;
+		break;
-case 24:
+	    case 24:
-for (__dstY = 0; __dstY < __newHeight; __dstY++) {
+		for (__dstY = 0; __dstY < __newHeight; __dstY++) {
-double __pY, __sinPY, __cosPY;
+		    double __pY, __sinPY, __cosPY;
 #ifdef EARLY_OUT
-int didFetchInRow = 0;
+		    int didFetchInRow = 0;
 #endif
-__pY = (double)(__dstY + __minY);
+		    __pY = (double)(__dstY + __minY);
-__sinPY = __sin * __pY;
+		    __sinPY = __sin * __pY;
-__cosPY = __cos * __pY;
+		    __cosPY = __cos * __pY;
-__dstPtr = __dstRowPtr;
+		    __dstPtr = __dstRowPtr;
-__dstRowPtr += __dstBytesPerRow;
+		    __dstRowPtr += __dstBytesPerRow;
-for (__dstX = 0; __dstX < __newWidth; __dstX++) {
+		    for (__dstX = 0; __dstX < __newWidth; __dstX++) {
-double __pX, __nX;
+			double __pX, __nX;
-unsigned __pix;
+			unsigned __pix;
-/* translate X in destination (center to 0/0) */
+			/* translate X in destination (center to 0/0) */
-__pX = (double)(__dstX + __minX);
+			__pX = (double)(__dstX + __minX);
-/* rotate X */
+			/* rotate X */
-__nX = (__cos * __pX) - __sinPY;
+			__nX = (__cos * __pX) - __sinPY;
-/* translate X in source (origin to 0/0) */
+			/* translate X in source (origin to 0/0) */
-__nX = __nX + __halfW + 0.5;
+			__nX = __nX + __halfW + 0.5;
-/* inside ? */
+			/* inside ? */
-if (__nX < 0) {
+			if (__nX < 0) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+			    if (didFetchInRow) {
-break;
+				break;
-}
+			    }
 #endif
-__pix = __blackPixel;
+			    __pix = __blackPixel;
-} else {
+			} else {
-int __srcX;
+			    int __srcX;
-__srcX = (int)__nX;
+			    __srcX = (int)__nX;
-/* inside ? */
+			    /* inside ? */
-if (__srcX >= __width) {
+			    if (__srcX >= __width) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+				if (didFetchInRow) {
-break;
+				    break;
-}
+				}
 #endif
-__pix = __blackPixel;
+				__pix = __blackPixel;
-} else {
+			    } else {
-double __nY;
+				double __nY;
-/* rotate Y */
+				/* rotate Y */
-__nY = (__sin * __pX) + __cosPY;
+				__nY = (__sin * __pX) + __cosPY;
-/* translate Y in source (origin to 0/0) */
+				/* translate Y in source (origin to 0/0) */
-__nY = __nY + __halfH + 0.5;
+				__nY = __nY + __halfH + 0.5;
-/* inside ? */
+				/* inside ? */
-if (__nY < 0) {
+				if (__nY < 0) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+				    if (didFetchInRow) {
-break;
+					break;
-}
+				    }
 #endif
-__pix = __blackPixel;
+				    __pix = __blackPixel;
-} else {
+				} else {
-int __srcY;
+				    int __srcY;
-__srcY = (int)__nY;
+				    __srcY = (int)__nY;
-/* inside ? */
+				    /* inside ? */
-if (__srcY >= __height) {
+				    if (__srcY >= __height) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+					if (didFetchInRow) {
-break;
+					    break;
-}
+					}
 #endif
-__pix = __blackPixel;
+					__pix = __blackPixel;
-} else {
+				    } else {
-/* fetch source pixel */
+					/* fetch source pixel */
-int idx;
+					int idx;
 #ifdef EARLY_OUT
-didFetchInRow = 1;
+					didFetchInRow = 1;
 #endif
-idx = __srcY * __srcBytesPerRow + __srcX + __srcX + __srcX;
+					idx = __srcY * __srcBytesPerRow + __srcX + __srcX + __srcX;
-if ((unsigned)idx < __nSrcBytes) {
+					if ((unsigned)idx < __nSrcBytes) {
-__pix = __srcBytes[idx];
+					    __pix = __srcBytes[idx];
-__pix = (__pix<<8) | __srcBytes[idx+1];
+					    __pix = (__pix<<8) | __srcBytes[idx+1];
-__pix = (__pix<<8) | __srcBytes[idx+2];
+					    __pix = (__pix<<8) | __srcBytes[idx+2];
-} else {
+					} else {
-__pix = __blackPixel;
+					    __pix = __blackPixel;
-}
+					}
-}
+				    }
-}
+				}
-}
+			    }
-}
+			}
-/* store pixel */
+			/* store pixel */
-if (__pix != 0) {
+			if (__pix != 0) {
-__dstPtr[0] = (__pix >> 16 & 0xFF);
+			    __dstPtr[0] = (__pix >> 16 & 0xFF);
-__dstPtr[1] = (__pix >> 8) & 0xFF;
+			    __dstPtr[1] = (__pix >> 8) & 0xFF;
-__dstPtr[2] = __pix & 0xFF;
+			    __dstPtr[2] = __pix & 0xFF;
-}
+			}
-__dstPtr += 3;
+			__dstPtr += 3;
-}
+		    }
-}
+		}
-break;
+		break;
-default:
+	    default:
-for (__dstY = 0; __dstY < __newHeight; __dstY++) {
+		for (__dstY = 0; __dstY < __newHeight; __dstY++) {
-double __pY, __sinPY, __cosPY;
+		    double __pY, __sinPY, __cosPY;
 #ifdef EARLY_OUT
-int didFetchInRow = 0;
+		    int didFetchInRow = 0;
 #endif
-__pY = (double)(__dstY + __minY);
+		    __pY = (double)(__dstY + __minY);
-__sinPY = __sin * __pY;
+		    __sinPY = __sin * __pY;
-__cosPY = __cos * __pY;
+		    __cosPY = __cos * __pY;
-__dstPtr = __dstRowPtr;
+		    __dstPtr = __dstRowPtr;
-__dstMask = 0x80;
+		    __dstMask = 0x80;
-__dstRowPtr += __dstBytesPerRow;
+		    __dstRowPtr += __dstBytesPerRow;
-for (__dstX = 0; __dstX < __newWidth; __dstX++) {
+		    for (__dstX = 0; __dstX < __newWidth; __dstX++) {
-double __pX, __nX;
+			double __pX, __nX;
-OBJ __pix;
+			OBJ __pix;
-/* translate X in destination (center to 0/0) */
+			/* translate X in destination (center to 0/0) */
-__pX = (double)(__dstX + __minX);
+			__pX = (double)(__dstX + __minX);
-/* rotate X */
+			/* rotate X */
-__nX = (__cos * __pX) - __sinPY;
+			__nX = (__cos * __pX) - __sinPY;
-/* translate X in source (origin to 0/0) */
+			/* translate X in source (origin to 0/0) */
-__nX = __nX + __halfW + 0.5;
+			__nX = __nX + __halfW + 0.5;
-/* inside ? */
+			/* inside ? */
-if (__nX < 0) {
+			if (__nX < 0) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+			    if (didFetchInRow) {
-break;
+				break;
-}
+			    }
 #endif
-__pix = blackPixel;
+			    __pix = blackPixel;
-} else {
+			} else {
-int __srcX;
+			    int __srcX;
-__srcX = (int)__nX;
+			    __srcX = (int)__nX;
-/* inside ? */
+			    /* inside ? */
-if (__srcX >= __width) {
+			    if (__srcX >= __width) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+				if (didFetchInRow) {
-break;
+				    break;
-}
+				}
 #endif
-__pix = blackPixel;
+				__pix = blackPixel;
-} else {
+			    } else {
-double __nY;
+				double __nY;
-/* rotate Y */
+				/* rotate Y */
-__nY = (__sin * __pX) + __cosPY;
+				__nY = (__sin * __pX) + __cosPY;
-/* translate Y in source (origin to 0/0) */
+				/* translate Y in source (origin to 0/0) */
-__nY = __nY + __halfH + 0.5;
+				__nY = __nY + __halfH + 0.5;
-/* inside ? */
+				/* inside ? */
-if (__nY < 0) {
+				if (__nY < 0) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+				    if (didFetchInRow) {
-break;
+					break;
-}
+				    }
 #endif
-__pix = blackPixel;
+				    __pix = blackPixel;
-} else {
+				} else {
-int __srcY;
+				    int __srcY;
-__srcY = (int)__nY;
+				    __srcY = (int)__nY;
-/* inside ? */
+				    /* inside ? */
-if (__srcY >= __height) {
+				    if (__srcY >= __height) {
 #ifdef EARLY_OUT
-if (didFetchInRow) {
+					if (didFetchInRow) {
-break;
+					    break;
-}
+					}
 #endif
-__pix = blackPixel;
+					__pix = blackPixel;
-} else {
+				    } else {
-/* fetch source pixel */
+					/* fetch source pixel */
-static struct inlineCache valAt = _ILC2;
+					static struct inlineCache valAt = _ILC2;
 #ifdef EARLY_OUT
-didFetchInRow = 1;
+					didFetchInRow = 1;
 #endif
-__pix = (*valAt.ilc_func)(self,
+					__pix = (*valAt.ilc_func)(self,
-@symbol(pixelAtX:y:),
+							      @symbol(pixelAtX:y:),
-nil, &valAt,
+							      nil, &valAt,
-__MKSMALLINT(__srcX),
+							      __MKSMALLINT(__srcX),
-__MKSMALLINT(__srcY));
+							      __MKSMALLINT(__srcY));
-}
+				    }
-}
+				}
-}
+			    }
-}
+			}
-/* store pixel */
+			/* store pixel */
-{
+			{
-static struct inlineCache atPutVal = _ILC3;
+			    static struct inlineCache atPutVal = _ILC3;
-if (__pix != __MKSMALLINT(0)) {
+			    if (__pix != __MKSMALLINT(0)) {
-(*atPutVal.ilc_func)(newImage,
+				(*atPutVal.ilc_func)(newImage,
-@symbol(pixelAtX:y:put:),
+						      @symbol(pixelAtX:y:put:),
-nil, &atPutVal,
+						      nil, &atPutVal,
-__MKSMALLINT(__dstX),
+						      __MKSMALLINT(__dstX),
-__MKSMALLINT(__dstY),
+						      __MKSMALLINT(__dstY),
-__pix
+						      __pix
-);
+						     );
-}
+			    }
-}
+			}
-}
+		    }
-}
+		}
-break;
+		break;
-}
+	}
-bad = false;
+	bad = false;
 }
 %}.
 bad ifTrue:[
-"/ should not happen
+	"/ should not happen
-self primitiveFailed
+	self primitiveFailed
 "/        sinRot := radians negated sin.
 "/        cosRot := radians negated cos.
 "/
 "/        0 to:newHeight-1 do:[:dstY |
 "/
 "/                    "/ inside ?
 "/                    (srcY >= 0 and:[srcY < height]) ifTrue:[
 "/                        pix := self pixelAtX:srcX y:srcY
 "/                    ] ifFalse:[
 "/                        pix := blackPixel.
 "/                    ].
 "/                ] ifFalse:[
 "/                    pix := blackPixel.
 "/                ].
 "/                pix ~~ blackPixel ifTrue:[
 "/                    newImage pixelAtX:dstX y:dstY put:pix.
 "/                ]
 "/            ].
 "/        ].
 ].
 "
 |i|
 i := Smalltalk imageFromFileNamed:'bitmaps/gifImages/garfield.gif' inPackage:'stx:goodies'.
 Transcript showCR:(
-Time millisecondsToRun:[
+	Time millisecondsToRun:[
-i rotated:45.
+	   i rotated:45.
-]
+	]
 ).
 "
 "
 |v i rI rot|
 i := Smalltalk imageFromFileNamed:'bitmaps/xpmBitmaps/misc_icons/BOOK.xpm' inPackage:'stx:goodies'.
 v := View new extent:(i width max:100)@(i height max:100).
 v openAndWait.
 rot := 0.
 [true] whileTrue:[
-rI := i rotated:rot.
+	rI := i rotated:rot.
-rI := rI onDevice:v device.
+	rI := rI onDevice:v device.
-v clear.
+	v clear.
-v displayForm:rI x:v width//2-(rI width//2) y:v height//2-(rI height // 2).
+	v displayForm:rI x:v width//2-(rI width//2) y:v height//2-(rI height // 2).
-rot := rot + 5.
+	rot := rot + 5.
-rI close.
+	rI close.
 ]
 "
 "
 |v i rI rot|
 i := Smalltalk imageFromFileNamed:'bitmaps/gifImages/claus.gif' inPackage:'stx:goodies'.
 v := View new extent:400@400.
 v openAndWait.
 rot := 0.
 [true] whileTrue:[
-rI := i rotated:rot.
+	rI := i rotated:rot.
-rI := rI onDevice:v device.
+	rI := rI onDevice:v device.
-v clear.
+	v clear.
-v displayForm:rI x:v width//2-(rI width//2) y:v height//2-(rI height // 2).
+	v displayForm:rI x:v width//2-(rI width//2) y:v height//2-(rI height // 2).
-rot := rot + 5.
+	rot := rot + 5.
-rI close.
+	rI close.
 ]
 "
 "Modified: 22.4.1997 / 17:36:37 / cg"
 !
 "return a new image which is slightly brighter than the receiver.
 The receiver must be a palette image (currently).
 CAVEAT: this only works with palette images (i.e. not for rgb or greyScale).
 CAVEAT: Need an argument, which specifies by how much it should be lighter."
 ^ self
-copyWithColorMapProcessing:[:clr | clr lightened]
+	copyWithColorMapProcessing:[:clr | clr lightened]
 "
 (Smalltalk bitmapFromFileNamed:'gifImages/claus.gif' inPackage:'stx:goodies') inspect
 (Smalltalk bitmapFromFileNamed:'gifImages/claus.gif' inPackage:'stx:goodies') lightened inspect
 (Smalltalk bitmapFromFileNamed:'gifImages/claus.gif' inPackage:'stx:goodies') darkened inspect
 mask notNil ifTrue:[
 	newMask := (mask magnifiedBy:scalePoint)
 ].
 newImage := self species new.
 newImage
 	width:newWidth
 	height:newHeight
 	photometric:photometric
 	samplesPerPixel:samplesPerPixel
 	bitsPerSample:bitsPerSample
 	colorMap:colorMap copy
 	bits:newBits
 	mask:newMask.
 mX = 1 ifTrue:[
 	srcOffset := 1.
 	dstOffset := 1.
 	1 to:h do:[:row |
 	    1 to:magY do:[:i |
 		newBits replaceFrom:dstOffset
 			to:(dstOffset + oldBytesPerRow - 1)
 			with:bytes
 			startingAt:srcOffset.
 		dstOffset := dstOffset + newBytesPerRow
 	    ].
 	    srcOffset := srcOffset + oldBytesPerRow.
 	].
 	"expand cols"
 	(mX > 1) ifTrue:[
 	    dstOffset := 1.
 	    srcOffset := 1.
 	    1 to:h do:[:row |
 		self magnifyRowFrom:bytes
 		     offset:srcOffset
 		     into:newBits
 		     offset:dstOffset
 		     factor:mX.
 		first := dstOffset.
 		dstOffset := dstOffset + newBytesPerRow.
 		" and copy for row expansion "
 		2 to:magY do:[:i |
 		    newBits replaceFrom:dstOffset
 			    to:(dstOffset + newBytesPerRow - 1)
 			    with:newBits
 			    startingAt:first.
 		    dstOffset := dstOffset + newBytesPerRow
 		].
 		srcOffset := srcOffset + oldBytesPerRow.
 	    ].
 "
 "Modified: 24.4.1997 / 18:32:04 / cg"
 !
 magnifiedPreservingRatioTo:anExtent
 "return a new image magnified to fit into anExtent,
 preserving the receivers width/height ratio.
 (i.e. not distorting the image).
 See also #magnifiedTo: and #magnifiedBy:"
 "
 "Modified: 22.4.1997 / 12:33:46 / cg"
 !
 magnifiedTo:anExtent
 "return a new image magnified to have the size specified by extent.
 This may distort the image if the arguments ratio is not the images ratio.
 See also #magnifiedPreservingRatioTo: and #magnifiedBy:"
 ^ self magnifiedBy:(anExtent / self extent)
 ((Image fromFile:'goodies/bitmaps/gifImages/garfield.gif') magnifiedPreservingRatioTo:100@100)
 "
 !
 mixed:amount with:aColor
 "return a new image which is blended with some color;
 amount determines how much of the blending color is applied (0..)
 where 0 means: blending color pure.
 The receiver must be a palette image (currently).
 CAVEAT: this only works with palette images (i.e. not for rgb or greyScale).
 CAVEAT: Need an argument, which specifies by how much it should be lighter."
 ^ self
 	copyWithColorMapProcessing:[:clr | clr mixed:amount with:aColor]
 "
 (Smalltalk bitmapFromFileNamed:'gifImages/claus.gif' inPackage:'stx:goodies') inspect
 ((Smalltalk bitmapFromFileNamed:'gifImages/claus.gif' inPackage:'stx:goodies') mixed:0.0 with:Color red) inspect
 	    ^ newImage
 	].
 	^ nil
 ].
 ^ self
 	copyWithColorMapProcessing:[:clr |
 		|newColor|
 		newColor := Color
 				redByte:(255 - clr redByte)
 				greenByte:(255 - clr greenByte)
 |xMax yMax r g b nR nG nB clr pix map revMap n_clr n_pix mask anyChange
 newColors newColorArray newImage extMask extBits newPixelValue|
 numBits > 7 ifTrue:[
-^ nil
+	^ nil
 ].
 mask := (16rFF bitShift:numBits) bitAnd:16rFF.
 extMask := (1 bitShift:numBits).
 extBits := extMask - 1.
 newImage mask:(self mask copy).
 xMax := width - 1.
 yMax := height - 1.
 newPixelValue :=
-[:image :pixelValue |
+	[:image :pixelValue |
-|r g b nR nG nB|
+	    |r g b nR nG nB|
-r := image redBitsOf:pixelValue.
+	    r := image redBitsOf:pixelValue.
-g := image greenBitsOf:pixelValue.
+	    g := image greenBitsOf:pixelValue.
-b := image blueBitsOf:pixelValue.
+	    b := image blueBitsOf:pixelValue.
-nR := r bitAnd:mask. (nR bitAnd:extMask)~~0 ifTrue:[nR := nR bitOr:extBits].
+	    nR := r bitAnd:mask. (nR bitAnd:extMask)~~0 ifTrue:[nR := nR bitOr:extBits].
-nG := g bitAnd:mask. (nG bitAnd:extMask)~~0 ifTrue:[nG := nG bitOr:extBits].
+	    nG := g bitAnd:mask. (nG bitAnd:extMask)~~0 ifTrue:[nG := nG bitOr:extBits].
-nB := b bitAnd:mask. (nB bitAnd:extMask)~~0 ifTrue:[nB := nB bitOr:extBits].
+	    nB := b bitAnd:mask. (nB bitAnd:extMask)~~0 ifTrue:[nB := nB bitOr:extBits].
-image valueFromRedBits:nR greenBits:nG blueBits:nB.
+	    image valueFromRedBits:nR greenBits:nG blueBits:nB.
-].
+	].
 photometric == #palette ifFalse:[
-"/ direct manipulation of the pixels
+	"/ direct manipulation of the pixels
-0 to:yMax do:[:y |
+	0 to:yMax do:[:y |
-0 to:xMax do:[:x |
+	    0 to:xMax do:[:x |
-pix := self pixelAtX:x y:y.
+		pix := self pixelAtX:x y:y.
-n_pix := newPixelValue value:self value:pix.
+		n_pix := newPixelValue value:self value:pix.
-n_pix ~= pix ifTrue:[
+		n_pix ~= pix ifTrue:[
-newImage pixelAtX:x y:y put:n_pix.
+		    newImage pixelAtX:x y:y put:n_pix.
-anyChange := true.
+		    anyChange := true.
-]
+		]
-]
+	    ]
-].
+	].
-anyChange ifFalse:[
+	anyChange ifFalse:[
-^ nil
+	    ^ nil
-].
+	].
 ] ifTrue:[
-"/ manipulate the colormap
+	"/ manipulate the colormap
-0 to:yMax do:[:y |
+	0 to:yMax do:[:y |
-0 to:xMax do:[:x |
+	    0 to:xMax do:[:x |
-pix := self pixelAtX:x y:y.
+		pix := self pixelAtX:x y:y.
-(n_pix := map at:pix+1) isNil ifTrue:[
+		(n_pix := map at:pix+1) isNil ifTrue:[
-clr := self colorAtX:x y:y.
+		    clr := self colorAtX:x y:y.
-r := clr redByte.
+		    r := clr redByte.
-g := clr greenByte.
+		    g := clr greenByte.
-b := clr blueByte.
+		    b := clr blueByte.
-nR := r bitAnd:mask. (nR bitAnd:extMask)~~0 ifTrue:[nR := nR bitOr:extBits].
+		    nR := r bitAnd:mask. (nR bitAnd:extMask)~~0 ifTrue:[nR := nR bitOr:extBits].
-nG := g bitAnd:mask. (nR bitAnd:extMask)~~0 ifTrue:[nR := nR bitOr:extBits].
+		    nG := g bitAnd:mask. (nR bitAnd:extMask)~~0 ifTrue:[nR := nR bitOr:extBits].
-nB := b bitAnd:mask. (nR bitAnd:extMask)~~0 ifTrue:[nR := nR bitOr:extBits].
+		    nB := b bitAnd:mask. (nR bitAnd:extMask)~~0 ifTrue:[nR := nR bitOr:extBits].
-n_clr := Color redByte:nR greenByte:nG blueByte:nB.
+		    n_clr := Color redByte:nR greenByte:nG blueByte:nB.
-(newColors includes:n_clr) ifFalse:[
+		    (newColors includes:n_clr) ifFalse:[
-newColors add:n_clr.
+			newColors add:n_clr.
-newColorArray add:n_clr.
+			newColorArray add:n_clr.
-revMap add:pix.
+			revMap add:pix.
-map at:pix+1 put:(n_pix := revMap size - 1).
+			map at:pix+1 put:(n_pix := revMap size - 1).
-] ifTrue:[
+		    ] ifTrue:[
-"/ mhmh - multiple pixels mapped to the same color
+			"/ mhmh - multiple pixels mapped to the same color
-n_pix := (newColorArray indexOf:n_clr) - 1.
+			n_pix := (newColorArray indexOf:n_clr) - 1.
-map at:pix+1 put:n_pix.
+			map at:pix+1 put:n_pix.
-]
+		    ]
-].
+		].
-newImage pixelAtX:x y:y put:n_pix.
+		newImage pixelAtX:x y:y put:n_pix.
-]
+	    ]
-].
+	].
-revMap size == self colorMap size ifTrue:[
+	revMap size == self colorMap size ifTrue:[
-revMap = (0 to:revMap size-1) ifTrue:[
+	    revMap = (0 to:revMap size-1) ifTrue:[
-^ nil
+		^ nil
-]
+	    ]
-].
+	].
-newImage colorMap:(MappedPalette withColors:newColorArray).
+	newImage colorMap:(MappedPalette withColors:newColorArray).
 ].
 ^ newImage
 !
 on the pixel colors.
 Notice: this method is very slow - either apply pixel values
 (#withPixelFunctionAppliedToPixels:) or redefine this method in
 a concrete subclass.
 (read `Beyond photography, by Gerard J. Holzmann;
-ISBM 0-13-074410-7)
+	   ISBM 0-13-074410-7)
 See blurred / oilPointed as examples ...)"
 |w  "{Class: SmallInteger }"
 h  "{Class: SmallInteger }"
 newImage "newBits newBytesPerRow"|
 w := width - 1.
 h := height - 1.
 0 to:h do:[:y |
-0 to:w do:[:x |
+	0 to:w do:[:x |
-newImage colorAtX:x y:y put:(pixelFunctionBlock
+	    newImage colorAtX:x y:y put:(pixelFunctionBlock
-value:self
+						value:self
-value:(self colorAtX:x y:y)
+						value:(self colorAtX:x y:y)
-value:x
+						value:x
-value:y)
+						value:y)
-]
+	]
 ].
 ^ newImage
 "black out everything except for some rectangle:
 i := Image fromFile:'goodies/bitmaps/gifImages/claus.gif'.
 i inspect.
 black := Color black.
 (i withPixelFunctionApplied:[:oldImage :oldColor :x :y |
-((x between:100 and:200)
+			((x between:100 and:200)
-and:[y between:100 and:200]) ifTrue:[
+			and:[y between:100 and:200]) ifTrue:[
-oldColor
+			    oldColor
-] ifFalse:[
+			] ifFalse:[
-black.
+			    black.
-]
+			]
-]) inspect.
+		     ]) inspect.
 "
 "brighten a frame:
 |i black w h|
 i inspect.
 w := i width.
 h := i height.
 (i withPixelFunctionApplied:[:oldImage :oldColor :x :y |
-((x between:0 and:10)
+			((x between:0 and:10)
-or:[(y between:0 and:10)
+			or:[(y between:0 and:10)
-or:[(x between:w-10 and:w)
+			or:[(x between:w-10 and:w)
-or:[y between:h-10 and:h]]]) ifTrue:[
+			or:[y between:h-10 and:h]]]) ifTrue:[
-oldColor lightened nearestIn:i colorMap
+			    oldColor lightened nearestIn:i colorMap
-] ifFalse:[
+			] ifFalse:[
-oldColor.
+			    oldColor.
-]
+			]
-]) inspect.
+		     ]) inspect.
 "
 "Modified: 24.4.1997 / 18:36:59 / cg"
 !
 on the pixel values.
 (read `Beyond photography, by Gerard J. Holzmann;
 	   ISBM 0-13-074410-7)
 See blurred / oilPointed as examples ...)"
 ^ self
 	withPixelFunctionAppliedToPixels:pixelFunctionBlock
 	in:(0@0 corner:width@height)
 "oil painting effect:
 |i w h|
 withPixelFunctionAppliedToPixels:pixelFunctionBlock in:aRectangle
 "return a new image from the old one, by applying a pixel processor
 on the pixel values.
 (read `Beyond photography, by Gerard J. Holzmann;
-ISBM 0-13-074410-7)
+	   ISBM 0-13-074410-7)
 See blurred / oilPointed as examples ...)"
 |newImage "newBits newBytesPerRow"|
 newImage := self species new.
 i := Image fromFile:'goodies/bitmaps/gifImages/claus.gif'.
 i inspect.
 w := i width - 1.
 h := i height - 1.
 (i withPixelFunctionAppliedToPixels:[:oldImage :oldPixel :x :y |
-|b p max xMin xMax yMin yMax|
+			|b p max xMin xMax yMin yMax|
-b := Bag identityNew:10.
+			b := Bag identityNew:10.
-xMin := x-3 max:0.
+			xMin := x-3 max:0.
-xMax := x+3 min:w.
+			xMax := x+3 min:w.
-yMin := y-3 max:0.
+			yMin := y-3 max:0.
-yMax := y+3 min:h.
+			yMax := y+3 min:h.
-xMin to:xMax do:[:tx|
+			xMin to:xMax do:[:tx|
-yMin to:yMax do:[:ty|
+			  yMin to:yMax do:[:ty|
-b add:(oldImage pixelAtX:tx y:ty)
+			    b add:(oldImage pixelAtX:tx y:ty)
-]
+			  ]
-].
+			].
-max := 0.
+			max := 0.
-b contents keysAndValuesDo:[:pixel :n |
+			b contents keysAndValuesDo:[:pixel :n |
-n > max ifTrue:[
+			    n > max ifTrue:[
-p := pixel.
+				p := pixel.
-max := n
+				max := n
-]
+			    ]
-].
+			].
-p
+			p
-]) inspect.
+		     ]) inspect.
 "
 "fisheye effect:
 |i w h w2 h2 R white|
 w2 := w // 2.
 h2 := h // 2.
 R := w2.
 white := i valueFromColor:Color white.
 (i withPixelFunctionAppliedToPixels:[:oldImage :oldPixel :x :y |
-|p r a nR nP nX nY|
+			|p r a nR nP nX nY|
-p := (x-w2)@(y-h2).
+			p := (x-w2)@(y-h2).
-r := p r.
+			r := p r.
-a := p theta.
+			a := p theta.
-nR := r * r / R.
+			nR := r * r / R.
-nP := Point r:nR theta:a.
+			nP := Point r:nR theta:a.
-nX := ((nP x+w2) rounded max:0) min:w.
+			nX := ((nP x+w2) rounded max:0) min:w.
-nY := ((nP y+h2) rounded max:0) min:h.
+			nY := ((nP y+h2) rounded max:0) min:h.
-(nX > w or:[nX < 0]) ifTrue:[
+			(nX > w or:[nX < 0]) ifTrue:[
-white
+			    white
-] ifFalse:[
+			] ifFalse:[
-(nY > h or:[nY < 0]) ifTrue:[
+			    (nY > h or:[nY < 0]) ifTrue:[
-white
+				white
-] ifFalse:[
+			    ] ifFalse:[
-oldImage pixelAtX:nX y:nY
+				oldImage pixelAtX:nX y:nY
-]
+			    ]
-]
+			]
-]) inspect.
+		     ]) inspect.
 "
 "fisheye effect:
 |i w h w2 h2 R white|
 w2 := w // 2.
 h2 := h // 2.
 R := w2.
 white := i valueFromColor:Color white.
 (i withPixelFunctionAppliedToPixels:[:oldImage :oldPixel :x :y |
-|p r a nR nP nX nY|
+			|p r a nR nP nX nY|
-p := (x-w2)@(y-h2).
+			p := (x-w2)@(y-h2).
-r := p r.
+			r := p r.
-a := p theta.
+			a := p theta.
-nR := r * r / R.
+			nR := r * r / R.
-nP := Point r:nR theta:a.
+			nP := Point r:nR theta:a.
-nX := (nP x+w2) rounded.
+			nX := (nP x+w2) rounded.
-nY := (nP y+h2) rounded.
+			nY := (nP y+h2) rounded.
-(nX > w or:[nX < 0]) ifTrue:[
+			(nX > w or:[nX < 0]) ifTrue:[
-white
+			    white
-] ifFalse:[
+			] ifFalse:[
-(nY > h or:[nY < 0]) ifTrue:[
+			    (nY > h or:[nY < 0]) ifTrue:[
-white
+				white
-] ifFalse:[
+			    ] ifFalse:[
-oldImage pixelAtX:nX y:nY
+				oldImage pixelAtX:nX y:nY
-]
+			    ]
-]
+			]
-]) inspect.
+		     ]) inspect.
 "
 "Created: 24.4.1997 / 18:37:17 / cg"
 "Modified: 24.4.1997 / 18:40:02 / cg"
 ! !
 applyPixelValuesTo:pixelFunctionBlock into:newImage in:aRectangle
 "helper for withPixelFunctionAppliedToValues:
 enumerate pixelValues and evaluate the block for each.
 To be redefined by subclasses for better performance."
 ^ self applyPixelValuesTo:pixelFunctionBlock in:aRectangle into:newImage
 !
 magnifyBy:scale
 "obsolete: has been renamed to magnifiedBy: for ST-80 compatibility
 and name consistency ..."
 colorMap - otherwise, an error will be reported.
 WARNING:
 This implementation is a very slow fallback general algorithm
 (the loop over the source pixels is very slow).
 If this method is used heavily, you may want to redefine it in
 concrete subclasses for the common case of of copying from an Image
 with the same depth & palette.
 If you do heavy image processing, specialized versions are even req'd
 for other cases, rewriting the inner loops as inline C-code."
 |dX dY|
 dX := srcX-dstX.
 dY := srcY-dstY.
 ((photometric == anImage photometric)
 and:[self bitsPerPixel == anImage bitsPerPixel
 and:[colorMap = anImage colorMap]]) ifTrue:[
-"/ can loop over values
+	"/ can loop over values
-anImage valuesFromX:srcX  y:srcY
+	anImage valuesFromX:srcX  y:srcY
-toX:srcX+w-1 y:srcY+h-1
+			toX:srcX+w-1 y:srcY+h-1
-do:[:x :y :pixelValue |
+			 do:[:x :y :pixelValue |
-self pixelAtX:x-dX y:y-dY put:pixelValue.
+	    self pixelAtX:x-dX y:y-dY put:pixelValue.
-]
+	]
 ] ifFalse:[
-"/ must loop over colors - horribly slow
+	"/ must loop over colors - horribly slow
-anImage colorsFromX:srcX  y:srcY
+	anImage colorsFromX:srcX  y:srcY
-toX:srcX+w-1 y:srcY+h-1
+			toX:srcX+w-1 y:srcY+h-1
-do:[:x :y :clr |
+			 do:[:x :y :clr |
-self colorAtX:x-dX y:y-dY put:clr.
+	    self colorAtX:x-dX y:y-dY put:clr.
-]
+	]
 ].
 (mask isNil and:[anImage mask notNil]) ifTrue:[
-"/ I have no mask; copied image has
+	"/ I have no mask; copied image has
-self createMask.
+	self createMask.
 ].
 mask notNil ifTrue:[
-anImage mask notNil ifTrue:[
+	anImage mask notNil ifTrue:[
-"/ both have a mask
+	    "/ both have a mask
-mask copyFrom:anImage mask x:srcX y:srcY toX:dstX y:dstY width:w height:h
+	    mask copyFrom:anImage mask x:srcX y:srcY toX:dstX y:dstY width:w height:h
-] ifFalse:[
+	] ifFalse:[
-"/ I have a mask - copied image has not
+	    "/ I have a mask - copied image has not
-mask fillRectangleX:dstX y:dstY width:w height:h withValue:1
+	    mask fillRectangleX:dstX y:dstY width:w height:h withValue:1
-]
+	]
 "/    ] ifFalse:[
 "/        anImage mask notNil ifTrue:[
 "/            "/ I have no mask; copied image has (already handled)
 "/        ] ifFalse:[
 "/            "/ none has a mask - nothing to do.
 aStream nextPutAll:'(' , self class name , ' new)'.
 aStream nextPutAll:' width: '. width storeOn:aStream.
 aStream nextPutAll:'; height: '. height storeOn:aStream.
 aStream nextPutAll:'; photometric:('. photometric storeOn:aStream.
 aStream nextPutAll:'); bitsPerSample:('. bitsPerSample storeOn:aStream.
 aStream nextPutAll:'); samplesPerPixel:('. samplesPerPixel storeOn:aStream.
 aStream nextPutAll:'); bits:(ByteArray fromPackedString:'. self bits asPackedString storeOn:aStream. aStream nextPutAll:') '.
 colorMap notNil ifTrue:[
-self depth <= 8 ifTrue:[
+	self depth <= 8 ifTrue:[
-"/ cut off unused colors ...
+	    "/ cut off unused colors ...
-usedValues := self usedValues.
+	    usedValues := self usedValues.
-colors := colorMap copyFrom:1 to:((usedValues max+1) min:colorMap size).
+	    colors := colorMap copyFrom:1 to:((usedValues max+1) min:colorMap size).
-colorMapArray := OrderedCollection new.
+	    colorMapArray := OrderedCollection new.
-colors do:[:clr| colorMapArray add:(clr redByte); add:(clr greenByte); add:(clr blueByte)].
+	    colors do:[:clr| colorMapArray add:(clr redByte); add:(clr greenByte); add:(clr blueByte)].
-aStream nextPutAll:'; colorMapFromArray:'.
+	    aStream nextPutAll:'; colorMapFromArray:'.
-colorMapArray asByteArray storeOn:aStream.
+	    colorMapArray asByteArray storeOn:aStream.
-] ifFalse:[
+	] ifFalse:[
-aStream nextPutAll:'; colorMap:('.
+	    aStream nextPutAll:'; colorMap:('.
-colorMap storeOn:aStream.
+	    colorMap storeOn:aStream.
-aStream nextPutAll:')'
+	    aStream nextPutAll:')'
-]
+	]
 ].
 mask notNil ifTrue:[
-aStream nextPutAll:'; mask:('.
+	aStream nextPutAll:'; mask:('.
-mask storeOn:aStream.
+	mask storeOn:aStream.
-aStream nextPutAll:')'.
+	aStream nextPutAll:')'.
 ].
 aStream nextPutAll:'; yourself'
 "Modified: / 22.8.1998 / 12:55:21 / cg"
 ! !
 on it. The best format is the one with the same number or more bits per
 pixel. Here, the smallest format found which can represent enough pixels is taken."
 |bestDeviceDepth
 bestDeviceBitsPerPixel "{ Class: SmallInteger }"
 "maxDepth"
 bestInfo maxInfo
 myDepth                "{ Class: SmallInteger }"
 maxBitsPerPixel        "{ Class: SmallInteger }"|
 myDepth := self bitsPerPixel.
 maxBitsPerPixel := 0.
 	"/ for now, ignore all depth's which are neither 1 nor the
 	"/ devices depth.
 	"/ (actually, many devices can handle other pixMap formats,
 	"/ but I dont know (yet) how to pass the correct color info
 	((deviceImageDepth == 1) or:[deviceImageDepth == aDevice depth]) ifTrue:[
 	    deviceImageBitsPerPixel > maxBitsPerPixel ifTrue:[
 		maxInfo := entry.
 "/            maxBitsPerPixel := deviceImageBitsPerPixel.
 		     or:[deviceImageBitsPerPixel < bestDeviceBitsPerPixel]) ifTrue:[
 			bestInfo := entry.
 			bestDeviceDepth := deviceImageDepth.
 			bestDeviceBitsPerPixel := deviceImageBitsPerPixel.
 		    ]
 		]
 	    ].
 	].
 ].
 bestDeviceDepth isNil ifTrue:[
 	].
 	photometric == #palette ifTrue:[
 	    self setColorMap:(anImage colorMap copy).
 	    "
 	     must generate/compress the colormap, if source image has higher depth
 	     than myself.
 	    "
 	    (colorMap isNil
 	    or:[anImage bitsPerPixel > self bitsPerPixel]) ifTrue:[
 		"
 		 get used colors are extracted into our colorMap
 "Modified: 10.1.1997 / 17:52:21 / cg"
 !
 greyByteMapForRange:range
 "return a collection to map from pixelValues to greyLevels
 in the range 0..range.
 Range must be < 256 (for elements to fit into a ByteArray).
 The values are rounded towards the nearest pixel."
 |d clr val greyMap r
 n "{ Class: SmallInteger }"|
 "
 "Modified: 1.3.1997 / 15:48:49 / cg"
 !
 magnifyRowFrom:srcBytes offset:srcStart
 	  into:dstBytes offset:dstStart factor:mX
 "magnify a single pixel row - can only magnify by integer factors,
 can only magnify 1,2,4,8 and 24 bit-per-pixel images. But this is done fast."
 ^ self subclassResponsibility
 !
 makeDeviceGrayPixmapOn:aDevice depth:depth fromArray:bits
 "given the bits of a grey/color bitmap, 8-bit padded and
 pixels interpreted as greyValues, 0 is black,
 create a device form for it"
 |f|
 f := Form width:width height:height depth:depth on:aDevice.
 (aDevice blackpixel ~~ 0) ifTrue:[
 	"/ have to invert bits
 	f function:#copyInverted
 ].
 aDevice
 	drawBits:bits
 	depth:depth
 	padding:8
 	width:width height:height
 	x:0 y:0
 	into:(f id)
 	x:0 y:0
 	width:width height:height
 	with:(f gcId).
 ^ f
 "Created: 10.6.1996 / 20:10:31 / cg"
 !
 "Modified: 17.4.1997 / 01:07:38 / cg"
 !
 makeDevicePixmapOn:aDevice depth:depth fromArray:bits
 "given the bits of a grey/color bitmap, 8-bit padded and
 pixels interpreted as in the devices colormap,
 create a device form for it"
 |f|
 f := Form width:width height:height depth:depth on:aDevice.
 f isNil ifTrue:[^ nil].
 f bits:bits.
 f initGC.
 aDevice
 	drawBits:bits
 	depth:depth
 	padding:8
 	width:width height:height
 	x:0 y:0
 	into:(f id)
 	x:0 y:0
 	width:width height:height
 	with:(f gcId).
 ^ f
 "Created: 10.6.1996 / 17:56:08 / cg"
 "Modified: 10.6.1996 / 20:11:27 / cg"
 averageColor
 "return the average color of the image.
 This usually only makes sense for textures and patterns
 (i.e. to compute shadow & light colors for viewBackgrounds).
 Notice, that for the above purpose, it is usually ok to process
 a subImage - i.e. use Image>>averageColorIn: on a smaller rectangle"
 ^ self averageColorIn:(0@0 corner:(width-1)@(height-1))
 !
 averageColorIn:aRectangle
 "return the images average color in an area.
 The implementation below is slow - so you may want to
 create tuned versions for DepthXImage if you plan to do
 heavy image processing ...
 (also, creating tuned versions of the enumeration messages helps a lot)"
 |x0 "{ Class:SmallInteger }"
 y0 "{ Class:SmallInteger }"
 x1 "{ Class:SmallInteger }"
 y1 "{ Class:SmallInteger }"
 sumRed sumGreen sumBlue n|
 sumRed := sumGreen := sumBlue := 0.
 y0 := aRectangle top.
 y1 := aRectangle bottom.
 x0 := aRectangle left.
 x1 := aRectangle right.
 n := (x1 - x0 + 1) * (y1 - y0 + 1).
 mask isNil ifTrue:[
 	self colorsFromX:x0 y:y0 toX:x1 y:y1 do:[:x :y :colorAtXY |
 	    sumRed := sumRed + colorAtXY red.
 	    sumGreen := sumGreen + colorAtXY green.
 	    sumBlue := sumBlue + colorAtXY blue.
 |p maxPixel clr r g b c m y k|
 p := photometric.
 p isNil ifTrue:[
-colorMap notNil ifTrue:[
+	colorMap notNil ifTrue:[
-p := #palette
+	    p := #palette
-] ifFalse:[
+	] ifFalse:[
 "/            'Image [warning]: no photometric - assume greyscale' infoPrintCR
-p := #blackIs0
+	    p := #blackIs0
-]
+	]
 ].
 p == #blackIs0 ifTrue:[
-maxPixel := (1 bitShift:self bitsPerPixel) - 1.
+	maxPixel := (1 bitShift:self bitsPerPixel) - 1.
-^ Color gray:(pixelValue * (100 / maxPixel)).
+	^ Color gray:(pixelValue * (100 / maxPixel)).
 ].
 p == #whiteIs0 ifTrue:[
-maxPixel := (1 bitShift:self bitsPerPixel) - 1.
+	maxPixel := (1 bitShift:self bitsPerPixel) - 1.
-^ Color gray:100 - (pixelValue * (100 / maxPixel)).
+	^ Color gray:100 - (pixelValue * (100 / maxPixel)).
 ].
 p == #palette ifTrue:[
-pixelValue >= colorMap size ifTrue:[
+	pixelValue >= colorMap size ifTrue:[
-^ Color black
+	    ^ Color black
-].
+	].
-clr := colorMap at:(pixelValue + 1).
+	clr := colorMap at:(pixelValue + 1).
-clr isNil ifTrue:[
+	clr isNil ifTrue:[
-^ Color black.
+	    ^ Color black.
-].
+	].
-^ clr.
+	^ clr.
 ].
 p == #rgb ifTrue:[
-r := self redBitsOf:pixelValue.
+	r := self redBitsOf:pixelValue.
-g := self greenBitsOf:pixelValue.
+	g := self greenBitsOf:pixelValue.
-b := self blueBitsOf:pixelValue.
+	b := self blueBitsOf:pixelValue.
-"/ must scale to byte value...
+	"/ must scale to byte value...
-r := r bitShift:(8 - (bitsPerSample at:1)).
+	r := r bitShift:(8 - (bitsPerSample at:1)).
-g := g bitShift:(8 - (bitsPerSample at:2)).
+	g := g bitShift:(8 - (bitsPerSample at:2)).
-b := b bitShift:(8 - (bitsPerSample at:3)).
+	b := b bitShift:(8 - (bitsPerSample at:3)).
-^ Color redByte:r greenByte:g blueByte:b
+	^ Color redByte:r greenByte:g blueByte:b
 ].
 p == #cmyk ifTrue:[
-c := self cyanComponentOfCMYK:pixelValue.
+	c := self cyanComponentOfCMYK:pixelValue.
-m := self magentaComponentOfCMYK:pixelValue.
+	m := self magentaComponentOfCMYK:pixelValue.
-y := self yellowComponentOfCMYK:pixelValue.
+	y := self yellowComponentOfCMYK:pixelValue.
-k := self blackComponentOfCMYK:pixelValue.
+	k := self blackComponentOfCMYK:pixelValue.
-^ Color cyan:c magenta:m yellow:y black:k.
+	^ Color cyan:c magenta:m yellow:y black:k.
 ].
 p == #cmy ifTrue:[
-c := self cyanComponentOfCMY:pixelValue.
+	c := self cyanComponentOfCMY:pixelValue.
-m := self magentaComponentOfCMY:pixelValue.
+	m := self magentaComponentOfCMY:pixelValue.
-y := self yellowComponentOfCMY:pixelValue.
+	y := self yellowComponentOfCMY:pixelValue.
-^ Color cyan:c magenta:m yellow:y.
+	^ Color cyan:c magenta:m yellow:y.
 ].
 self error:'invalid (unsupported) photometric'
 "Created: 8.6.1996 / 08:46:18 / cg"
 "return the shift amount used with translation from pixelValues to greenBits"
 |greenBits|
 samplesPerPixel >= 3 ifTrue:[
-greenBits := bitsPerSample at:3.
+	greenBits := bitsPerSample at:3.
-^ greenBits negated
+	^ greenBits negated
 ].
 self subclassResponsibility
 !
 "Modified: 24.4.1997 / 15:34:34 / cg"
 !
 realColorMap
 "return a collection usable as a real colormap of the image.
 For palette images, this is the internal colormap;
 for other photometrics (which do not have a real colormap), synthesize one.
 This is different from #colorMap, which returns nil for non palette images."
 |d nEntries "{ Class: SmallInteger }"
 colorArray|
 |set last|
 set := IdentitySet new.
 self valuesFromX:0 y:0 toX:(self width-1) y:(self height-1) do:[:x :y :pixel |
-pixel ~~ last ifTrue:[
+	pixel ~~ last ifTrue:[
-set add:pixel.
+	    set add:pixel.
-last := pixel.
+	    last := pixel.
-]
+	]
 ].
 ^ set
 "
 (Image fromFile:'goodies/bitmaps/gifImages/garfield.gif') usedValues
 	greenBits := bitsPerSample at:2.
 	blueBits := bitsPerSample at:3.
 	s := (1 bitShift:redBits) - 1.
 	^ 100.0 / s *
 	  ((pixel bitShift:(greenBits + blueBits) negated)
 	   bitAnd:(1 bitShift:redBits)-1)
 ].
 self subclassResponsibility
 |p maxPixel clr r g b c m y k|
 p := photometric.
 p isNil ifTrue:[
-colorMap notNil ifTrue:[
+	colorMap notNil ifTrue:[
-p := #palette
+	    p := #palette
-] ifFalse:[
+	] ifFalse:[
 "/            'Image [warning]: no photometric - assume greyscale' infoPrintCR
-p := #blackIs0
+	    p := #blackIs0
-]
+	]
 ].
 p == #blackIs0 ifTrue:[
-maxPixel := (1 bitShift:self bitsPerPixel) - 1.
+	maxPixel := (1 bitShift:self bitsPerPixel) - 1.
-b := pixelValue * 255 // maxPixel.
+	b := pixelValue * 255 // maxPixel.
-^ (((b bitShift:8) bitOr:b) bitShift:8) bitOr:b
+	^ (((b bitShift:8) bitOr:b) bitShift:8) bitOr:b
 ].
 p == #whiteIs0 ifTrue:[
-maxPixel := (1 bitShift:self bitsPerPixel) - 1.
+	maxPixel := (1 bitShift:self bitsPerPixel) - 1.
-b := 255 - (pixelValue * 255 // maxPixel).
+	b := 255 - (pixelValue * 255 // maxPixel).
-^ (((b bitShift:8) bitOr:b) bitShift:8) bitOr:b
+	^ (((b bitShift:8) bitOr:b) bitShift:8) bitOr:b
 ].
 p == #palette ifTrue:[
-pixelValue >= colorMap size ifTrue:[
+	pixelValue >= colorMap size ifTrue:[
-^ 0 "/ black
+	    ^ 0 "/ black
-].
+	].
-clr := colorMap at:(pixelValue + 1).
+	clr := colorMap at:(pixelValue + 1).
-clr isNil ifTrue:[
+	clr isNil ifTrue:[
-^ 0 "/ black
+	    ^ 0 "/ black
-].
+	].
-^ clr rgbValue.
+	^ clr rgbValue.
 ].
 p == #rgb ifTrue:[
-r := self redBitsOf:pixelValue.
+	r := self redBitsOf:pixelValue.
-g := self greenBitsOf:pixelValue.
+	g := self greenBitsOf:pixelValue.
-b := self blueBitsOf:pixelValue.
+	b := self blueBitsOf:pixelValue.
-"/ must scale to byte value...
+	"/ must scale to byte value...
-r := r bitShift:(8 - (bitsPerSample at:1)).
+	r := r bitShift:(8 - (bitsPerSample at:1)).
-g := g bitShift:(8 - (bitsPerSample at:2)).
+	g := g bitShift:(8 - (bitsPerSample at:2)).
-b := b bitShift:(8 - (bitsPerSample at:3)).
+	b := b bitShift:(8 - (bitsPerSample at:3)).
-^ (((r bitShift:8) bitOr:g) bitShift:8) bitOr:b
+	^ (((r bitShift:8) bitOr:g) bitShift:8) bitOr:b
 ].
 p == #cmyk ifTrue:[
-c := self cyanComponentOfCMYK:pixelValue.
+	c := self cyanComponentOfCMYK:pixelValue.
-m := self magentaComponentOfCMYK:pixelValue.
+	m := self magentaComponentOfCMYK:pixelValue.
-y := self yellowComponentOfCMYK:pixelValue.
+	y := self yellowComponentOfCMYK:pixelValue.
-k := self blackComponentOfCMYK:pixelValue.
+	k := self blackComponentOfCMYK:pixelValue.
-^ (Color cyan:c magenta:m yellow:y black:k) rgbValue.
+	^ (Color cyan:c magenta:m yellow:y black:k) rgbValue.
 ].
 p == #cmy ifTrue:[
-c := self cyanComponentOfCMY:pixelValue.
+	c := self cyanComponentOfCMY:pixelValue.
-m := self magentaComponentOfCMY:pixelValue.
+	m := self magentaComponentOfCMY:pixelValue.
-y := self yellowComponentOfCMY:pixelValue.
+	y := self yellowComponentOfCMY:pixelValue.
-^ (Color cyan:c magenta:m yellow:y) rgbValue.
+	^ (Color cyan:c magenta:m yellow:y) rgbValue.
 ].
 self error:'invalid (unsupported) photometric'
 !
 |colors|
 colors := self usedColorsMax:4096.
 colors isNil ifTrue:[
-self error:'too many colors in image'.
+	self error:'too many colors in image'.
 ].
 ^ colors
 "
 (Image fromFile:'goodies/bitmaps/gifImages/garfield.gif') usedColors
 (useful when searching rgb images)."
 |usedValues max colors|
 photometric == #rgb ifTrue:[
-usedValues := IdentitySet new.
+	usedValues := IdentitySet new.
-self valuesFromX:0 y:0 toX:(width-1) y:(height-1)
+	self valuesFromX:0 y:0 toX:(width-1) y:(height-1)
-do:[:x :y :pixel |
+	  do:[:x :y :pixel |
-usedValues add:pixel.
+	    usedValues add:pixel.
-usedValues size > nMax ifTrue:[
+	    usedValues size > nMax ifTrue:[
-"/ too many to be returned here (think of the mass of
+		"/ too many to be returned here (think of the mass of
-"/ data to be returned by a 24bit image ... ;-)
+		"/ data to be returned by a 24bit image ... ;-)
-^ nil
+		^ nil
-]
+	    ]
-].
+	].
-"/ code below is slightly faster ...
+	"/ code below is slightly faster ...
-"/ colors := usedValues collect:[:pixel | self colorFromValue:pixel].
+	"/ colors := usedValues collect:[:pixel | self colorFromValue:pixel].
-colors := usedValues collect:[:pixel | |r g b|
+	colors := usedValues collect:[:pixel | |r g b|
-r := self redBitsOf:pixel.
+					r := self redBitsOf:pixel.
-g := self greenBitsOf:pixel.
+					g := self greenBitsOf:pixel.
-b := self blueBitsOf:pixel.
+					b := self blueBitsOf:pixel.
-"/ must scale to byte value...
+					"/ must scale to byte value...
-r := r bitShift:(8 - (bitsPerSample at:1)).
+					r := r bitShift:(8 - (bitsPerSample at:1)).
-g := g bitShift:(8 - (bitsPerSample at:2)).
+					g := g bitShift:(8 - (bitsPerSample at:2)).
-b := b bitShift:(8 - (bitsPerSample at:3)).
+					b := b bitShift:(8 - (bitsPerSample at:3)).
-Color redByte:r greenByte:g blueByte:b
+					Color redByte:r greenByte:g blueByte:b
-].
+				     ].
-^ colors.
+	^ colors.
 ].
 usedValues := self usedValues asArray.
 photometric == #palette ifTrue:[
-colors := usedValues collect:[:val | (colorMap at:val+1 ifAbsent:[Color black])].
+	colors := usedValues collect:[:val | (colorMap at:val+1 ifAbsent:[Color black])].
 ] ifFalse:[
-"/ (photometric == #blackIs0 or:[photometric == #whiteIs0])
+	"/ (photometric == #blackIs0 or:[photometric == #whiteIs0])
-max := (1 bitShift:self depth) - 1.
+	max := (1 bitShift:self depth) - 1.
-colors :=  usedValues collect:[:val | (Color gray:(100 * val / max ))].
+	colors :=  usedValues collect:[:val | (Color gray:(100 * val / max ))].
 ].
 ^ colors asSet
 "
 (Image fromFile:'goodies/bitmaps/gifImages/garfield.gif') usedColors
 photometric == #rgb ifTrue:[
 	samplesPerPixel >= 3 ifTrue:[
 	    redBits := bitsPerSample at:1.
 	    greenBits := bitsPerSample at:2.
 	    blueBits := bitsPerSample at:3.
 	    "/ map r/g/b to 0..255
 	    r := (color red / 100.0 * ((1 bitShift:redBits)-1)) rounded.
 	    g := (color green / 100.0 * ((1 bitShift:greenBits)-1)) rounded.
 	    b := (color blue / 100.0 * ((1 bitShift:blueBits)-1)) rounded.
 	    pixel := (((r bitShift:greenBits) + g) bitShift:blueBits) + b.
 photometric == #rgb ifTrue:[
 	samplesPerPixel >= 3 ifTrue:[
 	    numGreenBits := bitsPerSample at:2.
 	    numBlueBits := bitsPerSample at:3.
 	    pixel := (((redBits bitShift:numGreenBits) + greenBits) bitShift:numBlueBits) + blueBits.
 	    ^ pixel
 	]
 ].
 ! !
 !Image methodsFor:'saving on file'!
 saveOn:aFileName
 "save the image in aFileName. The suffix of the filename controls the format.
 Currently, not all formats may be supported
 (see ImageReader subclasses implementing save:onFile:).
 May raise a signal, if the image cannot be written by the reader."
 |suffix readerClass|
 "Modified: 30.6.1997 / 22:06:34 / cg"
 !
 saveOn:aFileName using:readerClass
 "save the receiver using the representation class
 (which is usually a concrete subclasses of ImageReader).
 May raise a signal, if the image cannot be written by the reader."
 ^ readerClass save:self onFile:aFileName
 If its a view or rootView, it must be completely visible (or have
 the backingStore option turned on). Otherwise, only the clipped contents
 is returned. This is a common helper for form-to-image conversion,
 and to read hardcopy images from the screen."
 | visType
 x        "{ Class: SmallInteger }"
 y        "{ Class: SmallInteger }"
 w        "{ Class: SmallInteger }"
 h        "{ Class: SmallInteger }"
 dstIndex "{ Class: SmallInteger }"
 srcIndex "{ Class: SmallInteger }"
 srcRow   "{ Class: SmallInteger }"
 dstRow   "{ Class: SmallInteger }"
 inData tmpData usedPixels mapSize
 map bytesPerLine
 bitOrder spaceBitsPerPixel
 info bitsPerPixelIn bytesPerLineIn
 bitsR "{ Class: SmallInteger }"
 bitsG "{ Class: SmallInteger }"
 bitsB "{ Class: SmallInteger }"
 maskR "{ Class: SmallInteger }"
 maskG "{ Class: SmallInteger }"
 shB2 "{ Class: SmallInteger }"
 r "{ Class: SmallInteger }"
 g "{ Class: SmallInteger }"
 b "{ Class: SmallInteger }"
 word "{ Class: SmallInteger }"
 lword
 device ddepth isMSB|
 depth := self depth.
 bitsPerPixel := self bitsPerPixel.
 device := aDrawable graphicsDevice.
 (aDrawable isForm and:[aDrawable depth == 1]) ifTrue:[
-"/ a monochrome bitmap ?
+	"/ a monochrome bitmap ?
-visType := #StaticGray.
+	visType := #StaticGray.
-ddepth := 1.
+	ddepth := 1.
 ] ifFalse:[
-(aDrawable isForm) ifFalse:[
+	(aDrawable isForm) ifFalse:[
-"
+	    "
-get some attributes of the display device
+	     get some attributes of the display device
-"
+	    "
-visType := device visualType.
+	    visType := device visualType.
-ddepth := device depth.
+	    ddepth := device depth.
-] ifTrue:[
+	] ifTrue:[
-ddepth := aDrawable depth.
+	    ddepth := aDrawable depth.
-visType := aDrawable photometric
+	    visType := aDrawable photometric
-].
+	].
 ].
 "/ kludge for 15bit XFree server
 ddepth == 15 ifTrue:[
-ddepth := 16
+	ddepth := 16
 ].
 aDrawable isForm ifTrue:[
-photometric := aDrawable photometric.
+	photometric := aDrawable photometric.
-samplesPerPixel := ddepth == 24 ifTrue:3 ifFalse:1.
+	samplesPerPixel := ddepth == 24 ifTrue:3 ifFalse:1.
-bitsPerSample := ddepth == 24 ifTrue:#[8 8 8 ] ifFalse:[ByteArray with:bitsPerPixel].
+	bitsPerSample := ddepth == 24 ifTrue:#[8 8 8 ] ifFalse:[ByteArray with:bitsPerPixel].
 ] ifFalse:[
-(visType == #StaticGray) ifTrue:[
+	(visType == #StaticGray) ifTrue:[
-(device blackpixel == 0) ifTrue:[
+	    (device blackpixel == 0) ifTrue:[
-photometric := #blackIs0
+		photometric := #blackIs0
-] ifFalse:[
+	    ] ifFalse:[
-photometric := #whiteIs0
+		photometric := #whiteIs0
-].
+	    ].
-samplesPerPixel := 1.
+	    samplesPerPixel := 1.
-bitsPerPixel := ddepth.
+	    bitsPerPixel := ddepth.
-bitsPerSample := ByteArray with:bitsPerPixel.
+	    bitsPerSample := ByteArray with:bitsPerPixel.
-] ifFalse:[
+	] ifFalse:[
-((visType == #PseudoColor) or:[(visType == #StaticColor) or:[visType == #GrayScale]]) ifTrue:[
+	    ((visType == #PseudoColor) or:[(visType == #StaticColor) or:[visType == #GrayScale]]) ifTrue:[
-photometric := #palette.
+		photometric := #palette.
-samplesPerPixel := 1.
+		samplesPerPixel := 1.
-bitsPerPixel := ddepth.
+		bitsPerPixel := ddepth.
-bitsPerSample := ByteArray with:bitsPerPixel.
+		bitsPerSample := ByteArray with:bitsPerPixel.
-] ifFalse:[
+	    ] ifFalse:[
-((visType == #TrueColor) or:[visType == #DirectColor]) ifTrue:[
+		((visType == #TrueColor) or:[visType == #DirectColor]) ifTrue:[
-photometric := #rgb.
+		    photometric := #rgb.
-samplesPerPixel := 3.
+		    samplesPerPixel := 3.
 "/                bitsPerPixel := depth.
 "/                bitsPerSample := ByteArray with:device bitsRed
 "/                                       with:device bitsGreen
 "/                                       with:device bitsBlue
-bitsPerPixel := 24.
+		    bitsPerPixel := 24.
-bitsPerSample := #(8 8 8).
+		    bitsPerSample := #(8 8 8).
-] ifFalse:[
+		] ifFalse:[
-self error:'screen visual not supported'.
+		    self error:'screen visual not supported'.
-^ nil
+		    ^ nil
-]
+		]
-]
+	    ]
-].
+	].
 ].
 "
 dont know yet, how the display pads; assume worst case,
 offering enough space for 32 bit padding
 "
 w := width := aRectangle width.
 h := height := aRectangle height.
 x := aRectangle left.
 a kludge: we dont know in advance how much we are going to need
 (its too late when info is present ...)
 "
 spaceBitsPerPixel := bitsPerPixel.
 (bitsPerPixel > 8) ifTrue:[
-spaceBitsPerPixel := 16.
+	spaceBitsPerPixel := 16.
-(bitsPerPixel > 16) ifTrue:[
+	(bitsPerPixel > 16) ifTrue:[
-spaceBitsPerPixel := 32.
+	    spaceBitsPerPixel := 32.
-(bitsPerPixel > 32) ifTrue:[
+	    (bitsPerPixel > 32) ifTrue:[
-spaceBitsPerPixel := bitsPerPixel.
+		spaceBitsPerPixel := bitsPerPixel.
-]
+	    ]
-]
+	]
 ].
 bytesPerLine := (w * spaceBitsPerPixel + 31) // 32 * 4.
 "/ inData := ByteArray uninitializedNew:(bytesPerLine * height).
 inData := ByteArray new:(bytesPerLine * height).
 "
 get the pixels
 "
 aDrawable isForm ifTrue:[
-info := device getBitsFromPixmapId:aDrawable id x:x y:y width:w height:h into:inData.
+	info := device getBitsFromPixmapId:aDrawable id x:x y:y width:w height:h into:inData.
 ] ifFalse:[
-info := device getBitsFromViewId:aDrawable id x:x y:y width:w height:h into:inData.
+	info := device getBitsFromViewId:aDrawable id x:x y:y width:w height:h into:inData.
 ].
 bitsPerPixelIn := info at:#bitsPerPixel.
 isMSB := ((info at:#byteOrder) == #msbFirst).
 "/ check if bitorder is what I like (msbFirst)
 "/
 "/ mhmh - thats not needed
 bitsPerPixelIn < 8 ifTrue:[
-bitOrder := info at:#bitOrder.
+	bitOrder := info at:#bitOrder.
-bitOrder ~~ #msbFirst ifTrue:[
+	bitOrder ~~ #msbFirst ifTrue:[
-inData
+	    inData
-expandPixels:8
+		expandPixels:8
-width:(inData size)
+		width:(inData size)
-height:1
+		height:1
-into:inData
+		into:inData
-mapping:(ImageReader reverseBits "TODO: reverseBitsForDepth:bitsPerPixelIn").
+		mapping:(ImageReader reverseBits "TODO: reverseBitsForDepth:bitsPerPixelIn").
-].
+	].
 ].
 "
 check, if the devices padding is different ..
 or if the bitsPerPixels are different
 maskR := info at:#redMask ifAbsent:0.
 maskG := info at:#greenMask ifAbsent:0.
 maskB := info at:#blueMask ifAbsent:0.
 ((bytesPerLine ~~ bytesPerLineIn)
 or:[bitsPerPixelIn ~~ bitsPerPixel]) ifTrue:[
-tmpData := inData.
+	tmpData := inData.
-inData := ByteArray uninitializedNew:(bytesPerLine * height).
+	inData := ByteArray uninitializedNew:(bytesPerLine * height).
-srcRow := 1.
+	srcRow := 1.
-dstRow := 1.
+	dstRow := 1.
-bitsPerPixelIn ~~ bitsPerPixel ifTrue:[
+	bitsPerPixelIn ~~ bitsPerPixel ifTrue:[
-"/ for now, only 32 -> 24 is supported
+	    "/ for now, only 32 -> 24 is supported
-maskR == 0 ifTrue:[
+	    maskR == 0 ifTrue:[
-bitsR := device bitsRed.
+		bitsR := device bitsRed.
-bitsG := device bitsGreen.
+		bitsG := device bitsGreen.
-bitsB := device bitsBlue.
+		bitsB := device bitsBlue.
-maskR := (1 bitShift:bitsR) - 1.
+		maskR := (1 bitShift:bitsR) - 1.
-maskG := (1 bitShift:bitsG) - 1.
+		maskG := (1 bitShift:bitsG) - 1.
-maskB := (1 bitShift:bitsB) - 1.
+		maskB := (1 bitShift:bitsB) - 1.
-shR := device shiftRed negated.
+		shR := device shiftRed negated.
-shG := device shiftGreen negated.
+		shG := device shiftGreen negated.
-shB := device shiftBlue negated.
+		shB := device shiftBlue negated.
-] ifFalse:[
+	    ] ifFalse:[
-shR := (maskR lowBit - 1) negated.
+		shR := (maskR lowBit - 1) negated.
-bitsR := maskR highBit - maskR lowBit + 1.
+		bitsR := maskR highBit - maskR lowBit + 1.
-maskR := maskR bitShift:shR.
+		maskR := maskR bitShift:shR.
-shG := (maskG lowBit - 1) negated.
+		shG := (maskG lowBit - 1) negated.
-bitsG := maskG highBit - maskG lowBit + 1.
+		bitsG := maskG highBit - maskG lowBit + 1.
-maskG := maskG bitShift:shG.
+		maskG := maskG bitShift:shG.
-shB := (maskB lowBit - 1) negated.
+		shB := (maskB lowBit - 1) negated.
-bitsB := maskB highBit - maskB lowBit + 1.
+		bitsB := maskB highBit - maskB lowBit + 1.
-maskB := maskB bitShift:shB.
+		maskB := maskB bitShift:shB.
-].
+	    ].
-shR2 := (8 - bitsR).
+	    shR2 := (8 - bitsR).
-shG2 := (8 - bitsG).
+	    shG2 := (8 - bitsG).
-shB2 := (8 - bitsB).
+	    shB2 := (8 - bitsB).
-((bitsPerPixelIn == 32) and:[bitsPerPixel == 24]) ifTrue:[
+	    ((bitsPerPixelIn == 32) and:[bitsPerPixel == 24]) ifTrue:[
-"/ 'reformatting 32->24...' printNL.
+		"/ 'reformatting 32->24...' printNL.
-1 to:h do:[:hi |
+		1 to:h do:[:hi |
-srcIndex := srcRow.
+		    srcIndex := srcRow.
-dstIndex := dstRow.
+		    dstIndex := dstRow.
-1 to:w do:[:wi |
+		    1 to:w do:[:wi |
-lword := tmpData doubleWordAt:srcIndex MSB:isMSB.
+			lword := tmpData doubleWordAt:srcIndex MSB:isMSB.
-r := (lword bitShift:shR) bitAnd:maskR.
+			r := (lword bitShift:shR) bitAnd:maskR.
-g := (lword bitShift:shG) bitAnd:maskG.
+			g := (lword bitShift:shG) bitAnd:maskG.
-b := (lword bitShift:shB) bitAnd:maskB.
+			b := (lword bitShift:shB) bitAnd:maskB.
-inData at:dstIndex   put:r.
+			inData at:dstIndex   put:r.
-inData at:dstIndex+1 put:g.
+			inData at:dstIndex+1 put:g.
-inData at:dstIndex+2 put:b.
+			inData at:dstIndex+2 put:b.
-srcIndex := srcIndex + 4.
+			srcIndex := srcIndex + 4.
-dstIndex := dstIndex + 3.
+			dstIndex := dstIndex + 3.
-].
+		    ].
-dstRow := dstRow + bytesPerLine.
+		    dstRow := dstRow + bytesPerLine.
-srcRow := srcRow + bytesPerLineIn
+		    srcRow := srcRow + bytesPerLineIn
-]
+		]
-] ifFalse:[
+	    ] ifFalse:[
-((bitsPerPixelIn == 16) and:[bitsPerPixel == 24]) ifTrue:[
+		((bitsPerPixelIn == 16) and:[bitsPerPixel == 24]) ifTrue:[
-"/ 'reformatting 16->24...' printNL.
+		    "/ 'reformatting 16->24...' printNL.
-1 to:h do:[:hi |
+		    1 to:h do:[:hi |
-srcIndex := srcRow.
+			srcIndex := srcRow.
-dstIndex := dstRow.
+			dstIndex := dstRow.
-1 to:w do:[:wi |
+			1 to:w do:[:wi |
-word := tmpData wordAt:srcIndex MSB:isMSB.
+			    word := tmpData wordAt:srcIndex MSB:isMSB.
-r := (word bitShift:shR) bitAnd:maskR.
+			    r := (word bitShift:shR) bitAnd:maskR.
-g := (word bitShift:shG) bitAnd:maskG.
+			    g := (word bitShift:shG) bitAnd:maskG.
-b := (word bitShift:shB) bitAnd:maskB.
+			    b := (word bitShift:shB) bitAnd:maskB.
-inData at:dstIndex   put:(r bitShift:shR2).
+			    inData at:dstIndex   put:(r bitShift:shR2).
-inData at:dstIndex+1 put:(g bitShift:shG2).
+			    inData at:dstIndex+1 put:(g bitShift:shG2).
-inData at:dstIndex+2 put:(b bitShift:shB2).
+			    inData at:dstIndex+2 put:(b bitShift:shB2).
-srcIndex := srcIndex + 2.
+			    srcIndex := srcIndex + 2.
-dstIndex := dstIndex + 3.
+			    dstIndex := dstIndex + 3.
-].
+			].
-dstRow := dstRow + bytesPerLine.
+			dstRow := dstRow + bytesPerLine.
-srcRow := srcRow + bytesPerLineIn
+			srcRow := srcRow + bytesPerLineIn
-]
+		    ]
-] ifFalse:[
+		] ifFalse:[
-('Image [warning]: unsupported depth combination: ' , bitsPerPixelIn printString , ' -> ' ,
+		    ('Image [warning]: unsupported depth combination: ' , bitsPerPixelIn printString , ' -> ' ,
-bitsPerPixel printString) errorPrintCR.
+							bitsPerPixel printString) errorPrintCR.
-self shouldImplement.
+		    self shouldImplement.
-^ nil
+		    ^ nil
-]
+		]
-].
+	    ].
-] ifFalse:[
+	] ifFalse:[
-"/
+	    "/
-"/ repad in the buffer
+	    "/ repad in the buffer
-"/
+	    "/
-1 to:h do:[:hi |
+	    1 to:h do:[:hi |
-inData replaceFrom:dstRow to:(dstRow + bytesPerLine - 1)
+		inData replaceFrom:dstRow to:(dstRow + bytesPerLine - 1)
-with:tmpData startingAt:srcRow.
+			      with:tmpData startingAt:srcRow.
-dstRow := dstRow + bytesPerLine.
+		dstRow := dstRow + bytesPerLine.
-srcRow := srcRow + bytesPerLineIn
+		srcRow := srcRow + bytesPerLineIn
-]
+	    ]
-]
+	]
 ] ifFalse:[
-(bytesPerLine * height) ~~ inData size ifTrue:[
+	(bytesPerLine * height) ~~ inData size ifTrue:[
-tmpData := inData.
+	    tmpData := inData.
-inData := ByteArray uninitializedNew:(bytesPerLine * height).
+	    inData := ByteArray uninitializedNew:(bytesPerLine * height).
-inData replaceFrom:1 to:bytesPerLine * height with:tmpData startingAt:1
+	    inData replaceFrom:1 to:bytesPerLine * height with:tmpData startingAt:1
-]
+	]
 ].
 self bits:inData.
 "/
 "/  if not #palette we are done, the pixel values are the rgb/grey values
 "/
 photometric == #palette ifTrue:[
-"/
+	"/
-"/ what we have now are the color numbers - still need the r/g/b values.
+	"/ what we have now are the color numbers - still need the r/g/b values.
-"/ find out, which colors are in the picture
+	"/ find out, which colors are in the picture
-"/
+	"/
-usedPixels := inData usedValues.
+	usedPixels := inData usedValues.
-mapSize := usedPixels max + 1.
+	mapSize := usedPixels max + 1.
-"get the palette"
+	"get the palette"
-map := Array new:mapSize.
+	map := Array new:mapSize.
-usedPixels do:[:colorIndex |
+	usedPixels do:[:colorIndex |
-|i|
+	    |i|
-i := colorIndex + 1.
+	    i := colorIndex + 1.
-device getRGBFrom:colorIndex into:[:r :g :b |
+	    device getRGBFrom:colorIndex into:[:r :g :b |
-map at:i put:(Color red:r green:g blue:b)
+		map at:i put:(Color red:r green:g blue:b)
-]
+	    ]
-].
+	].
-self setColorMap:map.
+	self setColorMap:map.
 ].
 "Modified: / 9.1.1998 / 21:32:36 / stefan"
 "Modified: / 7.2.1998 / 18:23:07 / cg"
 !
 "read an image from the display screen.
 WARNING: this temporarily grabs the display
 	      it may not work from within a buttonMotion
 	      (use #fromScreen:on:grab: with a false grabArg then)."
 ^ self
 	fromScreen:aRectangle
 	on:Screen current
 	grab:true
 "Modified: 26.3.1997 / 10:43:34 / cg"
 !
 fromScreen:aRectangle on:aDevice
 "read an image from aDevices display screen.
 Since I have no other displays, only the MonoChrome, StaticGrey
 and PseudoColor cases have been tested ...
 (especially True- and DirectColor may be wrong).
 Late note: 24bit rgb now also works.
 WARNING: this temporarily grabs the display
 	      it may not work from within a buttonMotion
 	      (use #fromScreen:on:grab: with a false grabArg then)."
 ^ self
 	fromScreen:aRectangle
 	on:aDevice
 	grab:true
 "
 Image fromScreen:((0 @ 0) corner:(100 @ 100)) on:Display
 Image fromScreen:((0 @ 0) corner:(500 @ 500)) on:Display
 fromScreen:aRectangle on:aDevice grab:doGrab
 "read an image from aDevices display screen.
 If the doGrab argument is true, the display
 is grabbed (i.e. blocked for others) and a camera cursor is
 shown while the readout is done.
 Since I have no other displays, only the MonoChrome, StaticGrey
 and PseudoColor cases have been tested ...
 (especially True- and DirectColor may be wrong).
 Late note: 24bit rgb now also works.
 WARNING: with doGrab true, this temporarily grabs the display
-and it may not work from within a buttonMotion
+	      and it may not work from within a buttonMotion
-(use with a false grabArg then)."
+	      (use with a false grabArg then)."
 |curs rootView prevGrab|
 "/    doGrab ifTrue:[ |cid|
 "/        curs := Cursor sourceForm:(Image fromFile:'bitmaps/Camera.xbm')
 "
 actually have to grabServer ... but thats not yet available
 "
 rootView := aDevice rootView.
 doGrab ifTrue:[
-prevGrab := aDevice activePointerGrab.
+	prevGrab := aDevice activePointerGrab.
-aDevice grabPointerInView:rootView withCursor:curs.
+	aDevice grabPointerInView:rootView withCursor:curs.
 ].
 "
 get the pixels
 "
 [
-self from:rootView in:aRectangle.
+	self from:rootView in:aRectangle.
 ] ensure:[
-doGrab ifTrue:[
+	doGrab ifTrue:[
-aDevice ungrabPointer.
+	    aDevice ungrabPointer.
-prevGrab notNil ifTrue:[
+	    prevGrab notNil ifTrue:[
-aDevice grabPointerInView:prevGrab.
+		 aDevice grabPointerInView:prevGrab.
-]
+	    ]
-]
+	]
 ]
 "
 Image fromScreen:((100@100) corner:(200@200)) on:Display grab:false
 Image fromScreen:((100@100) corner:(200@200)) on:Display grab:true
 visType := aDevice visualType.
 depth := aDevice depth.
 "/ kludge for 15bit XFree server
 depth == 15 ifTrue:[
-depth := 16
+	depth := 16
 ].
 (visType == #StaticGray) ifTrue:[
-(aDevice blackpixel == 0) ifTrue:[
+	(aDevice blackpixel == 0) ifTrue:[
-photometric := #blackIs0
+	    photometric := #blackIs0
-] ifFalse:[
+	] ifFalse:[
-photometric := #whiteIs0
+	    photometric := #whiteIs0
-].
+	].
-samplesPerPixel := 1.
+	samplesPerPixel := 1.
-bitsPerPixel := depth.
+	bitsPerPixel := depth.
-bitsPerSample := ByteArray with:bitsPerPixel.
+	bitsPerSample := ByteArray with:bitsPerPixel.
-"
+	"
-were done, the pixel values are the grey values
+	 were done, the pixel values are the grey values
-"
+	"
-^ self
+	^ self
 ].
 ((visType == #TrueColor) or:[visType == #DirectColor]) ifTrue:[
-photometric := #rgb.
+	photometric := #rgb.
-samplesPerPixel := 3.
+	samplesPerPixel := 3.
-"/ for now - only support 24bit TrueColor
+	"/ for now - only support 24bit TrueColor
-depth ~~ 24 ifTrue:[
+	depth ~~ 24 ifTrue:[
-'IMAGE: unsupported display depth' errorPrintCR.
+	    'IMAGE: unsupported display depth' errorPrintCR.
-].
+	].
 "/                bitsPerPixel := depth.
 "/                bitsPerSample := ByteArray with:aDevice bitsRed
 "/                                       with:aDevice bitsGreen
 "/                                       with:aDevice bitsBlue
-bitsPerPixel := 24.
+	bitsPerPixel := 24.
-bitsPerSample := #[8 8 8].
+	bitsPerSample := #[8 8 8].
-"
+	"
-were done, the pixel values are the rgb values
+	 were done, the pixel values are the rgb values
-"
+	"
-^ self
+	^ self
 ].
 ((visType ~~ #PseudoColor)
 and:[(visType ~~ #StaticColor)
 and:[visType ~~ #GrayScale]]) ifTrue:[
-self error:'screen visual not supported'.
+	self error:'screen visual not supported'.
-^ nil
+	^ nil
 ].
 photometric := #palette.
 samplesPerPixel := 1.
 bitsPerPixel := depth.
 ! !
 !Image class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libview/Image.st,v 1.386 2006-09-18 19:49:19 cg Exp $'
+^ '$Header: /cvs/stx/stx/libview/Image.st,v 1.387 2007-01-24 13:40:55 cg Exp $'
 ! !
 Image initialize!

changeset 4717	c25149336a26
parent 4620	a9d593b2a056
child 4725	c8896df7bd3f