"

 COPYRIGHT (c) 1992 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

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

 inclusion of the above copyright notice.   This software may not

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

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

 hereby transferred.

"

Object subclass:#GraphicsContext

       instanceVariableNames:'paint bgPaint

			      function font

			      lineStyle lineWidth

			      joinStyle capStyle

			      mask maskOrigin transformation'

       classVariableNames:'White Black DefaultFont' 

       poolDictionaries:''

       category:'Graphics-Support'

!

!GraphicsContext class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1992 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

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

 inclusion of the above copyright notice.   This software may not

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

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

 hereby transferred.

"

!

version

!

documentation

"

    this is an abstract superclass for all kinds of graphic drawables -

    both windows and printed pages (i.e. printers) are inheriting from

    this class (even drawables not at all associated with any device would do so).

    Drawing is done in paint/bgPaint colors, which can be true colors (i.e.

    directly supported by the underlying hardware) or simulated colors

    (i.e. dithered colors or images).

    The paint/bgPaint instance variables are set to the logical colors,

    device specific drawable may like to keep actual colors in addition.

    The transformation instance variable is typically nil, for a 1-to-1

    coordinate mapping (i.e. x/y coordinates are pixels in the drawable).

    If nonNil, the transformation must be an  instance of WindowingTransformation

    and offers both a scale-factor and a translation.

    Also, drawing in metric- or inch-units can be done using transformations.

    (see instance creation methods of WindowingTransformation, and examples

     in 'doc/coding').

    All drawing is defined upon a few basic drawing methods, which must be 

    implemented by subclasses (some subclasses also redefine the others for

    more performance)

    Instance variables:

	paint           <Color>         the paint used for drawing

	bgPaint         <Color>         the background used for drawing texts and bitmaps

	function        <Symbol>        the drawing function (i.e. #copy, #or, #xor ...)

					- not all Drawables support every function

					(i.e. paper only allows #copy)

	font            <Font>          the current font to be used for drawing

	lineStyle       <Symbol>        the lineStyle (i.e. #solid, #dashed, #doubleDashed)

	lineWidth       <SmallInteger>  the lineWidth (device dependent, usually pixels)

	joinStyle       <Symbol>        the style in which lines (in polygons)

					are joined (i.e. #miter, #bevel, #round)

	capStyle        <Symbol>        the style in which the last point of a line is drawn

					(i.e. #notLast, #butt, #round, #projecting)

	mask            <Form>          a mask used for drawing

					- not all Drawables support it

	maskOrigin      <Point>         the origin of the mask relative to

					the drawables origin

    Class variables:

	White           <Color>         cached white color - its needed so often

	Black           <Color>         cached black color - its needed so often

	DefaultFont     <Font>          default font to use

"

! !

!GraphicsContext class methodsFor:'initialization'!

initialize

    "setup some defaults - these are usually redefined

     during startup."

    Color isNil ifTrue:[^ self].

    Display isNil ifTrue:[^ self].

    White isNil ifTrue:[

	Color initialize.

	White := Color white on:Display.

	Black := Color black on:Display.

	Font initialize.

	DefaultFont := Font family:'courier' face:'medium' style:'roman' size:12

    ]

! !

!GraphicsContext class methodsFor:'accessing defaults'!

defaultFont:aFont

    "set the default font used for drawing"

    DefaultFont := aFont

!

defaultFont

    "get the default font used for drawing"

    DefaultFont isNil ifTrue:[

	DefaultFont := Font family:'courier' face:'medium' style:'roman' size:12

    ].

    ^ DefaultFont

! !

!GraphicsContext class methodsFor:'constants'!

joinRound

    "return a constant to specify round join"

    ^ #round

!

joinMiter

    "return a constant to specify miter join"

    ^ #miter

!

joinBevel

    "return a constant to specify bevel join"

    ^ #bevel

!

capNotLast

    "return a constant to specify not-last cap"

    ^ #notLast

!

capProjecting

    "return a constant to specify projecting cap"

    ^ #projecting

!

capRound

    "return a constant to specify round cap"

    ^ #round

!

capButt

    "return a constant to specify butt cap"

    ^ #butt

! !

!GraphicsContext class methodsFor:'instance creation'!

new

    "return a new instance of myself. Redefined to initialize

     the new thingy"

    ^ self basicNew initialize

! !

!GraphicsContext methodsFor:'initialization'!

initialize

    "set up some useful default values"

    paint := Black.

    bgPaint := White.

    function := #copy.

    lineWidth := 1.

    lineStyle := #solid.

    joinStyle := #miter.

    capStyle := #butt.

    font := DefaultFont.

! !

!GraphicsContext methodsFor:'misc'!

flush

    "st-80 compatibility"

    self device flush

! !

!GraphicsContext methodsFor:'accessing'!

paint

    "return the current paint drawing color"

    ^ paint

!

paint:aColor

    "set the drawing painting color, aColor can be a dithered one"

    paint := aColor

!

paint:fgColor on:bgColor

    "set the paint used for text and bitmaps, both colors may be

     dithered colors"

    self paint:fgColor.

    bgPaint := bgColor

!

backgroundPaint

    "return the background paint color.

     (used for opaqueForms and opaqueStrings)"

    ^ bgPaint

!

backgroundPaint:aColor

    "set the background painting color (which is used for

     opaqueForms and opaqueStrings). aColor can be a dithered one."

    ^ self subclassResponsibility

!

function

    "return the current drawing function"

    ^ function

!

function:aFunctionSymbol

    "set the drawing function"

    ^ self subclassResponsibility

!

lineWidth

    "return the current drawing linewidth"

    ^ lineWidth

!

lineWidth:aNumber

    "set the line drawing width in pixels"

    lineWidth := aNumber

!

lineStyle

    "return the current line-drawing-style"

    ^ lineStyle

!

lineStyle:aStyleSymbol

    "set the line-drawing-style;

     possible styles are: #solid, #dashed, #doubleDashed"

    lineStyle := aStyleSymbol

!

capStyle

    "return the current cap-style for line-drawing"

    ^ capStyle

!

capStyle:aStyleSymbol

    "set the cap-style for line-drawing;

     possible styles are: #notLast, #butt, #round, #projecting"

    ^ self subclassResponsibility

!

joinStyle

    "return the current join-style for polygon-drawing"

    ^ joinStyle

!

joinStyle:aStyleSymbol

    "set the join-style of lines in polygon-drawing;

     possible styles are: #miter, #bevel, #round"

    ^ self subclassResponsibility

!

mask

    "return the current drawing mask"

    ^ mask

!

mask:aForm

    "set the drawing mask"

    ^ self subclassResponsibility

!

font

    "return the current drawing font"

    ^ font

!

font:aFont

    "set the drawing font"

    ^ self subclassResponsibility

!

clipRect

    "return the drawing clip-rectangle"

    ^ self subclassResponsibility

!

clipRect:aRectangle

    "set the drawing clip-rectangle"

    ^ self subclassResponsibility

!

clippingBounds

    "for ST-80 compatibility"

    ^ self clipRect

!

graphicsContext

    "for ST-80 compatibility"

    ^ self

!

viewOrigin

    "return the drawables visible origin (for scrolling)"

    ^ 0@0

!

phase

    "return the origin within the mask (used to draw with patterns).

     This is an alias for ST/X's #maskOrigin"

    ^ self maskOrigin

!

phase:aPoint

    "set the origin within the mask (used to draw with patterns).

     This is an alias for ST/X's #maskOrigin:"

    ^ self maskOrigin:aPoint

!

maskOrigin

    "return the origin within the mask (used to draw with patterns).

     Should be redefined in classes which support it.

     This is an alias for ST-80's #phase"

    ^ maskOrigin

!

maskOrigin:aPoint

    "set the origin within the mask (used to draw with patterns).

     Should be redefined in classes which support it.

     This is an alias for ST-80's #phase:"

    ^ self maskOriginX:aPoint x y:aPoint y

!

maskOriginX:x y:y 

    "set the origin within the mask (used to draw with patterns).

     Should be redefined in classes which support it.

     This is an alias for ST-80's #phase:"

    ^ self

!

setMaskOrigin:aPoint

    "set the origin within the mask (used to draw with patterns).

     OBSOLETE: use #maskOrigin: or #phase:"

    ^ self maskOrigin:aPoint

!

setMaskOriginX:x y:y

    "set the origin within the mask (used to draw with patterns).

     OBSOLETE: use #maskOriginX:y: or #phase:"

    ^ self maskOriginX:x y:y 

!

withPattern:aForm do:aBlock

    "draw with a pattern.

     Should be redefined in classes which support it"

    'pattern drawing not implemented' errorPrintNL.

    aBlock value

!

transformation 

    "return the transformation"

    ^ transformation

!

transformation:aTransformation 

    "set the transformation"

    transformation := aTransformation

! !

!GraphicsContext methodsFor:'ST-80 compatibility'!

findFont:aFontDescription

    ^ aFontDescription on:self device

!

widthOfString:aString

    ^ (font on:self device) widthOf:aString

!

widthOfString:aString from:start to:stop

    ^ (font on:self device) widthOf:aString from:start to:stop

! !

!GraphicsContext methodsFor:'ST-80 displaying'!

displayLineFrom:startPoint to:endPoint translateBy:anOffset

    "draw a line - ST-80 compatibility"

    self displayLineFrom:(startPoint + anOffset)

		      to:(endPoint + anOffset)

!

displayRectangularBorder:aRectangle at:aPoint

    "draw a rectangle - ST-80 compatibility"

    self displayRectangle:(aRectangle translateBy:aPoint)

!

displayPolyline:aPolygon

    "draw a polygon - ST-80 compatibility"

    ^ self displayPolygon:aPolygon 

!

displayArc:origin radius:radius from:startAngle angle:angle

    "draw an arc around a point"

    self displayArcX:(origin x - radius)

		   y:(origin y - radius)

		   w:(radius * 2) 

		   h:(radius * 2)

		from:startAngle angle:angle

!

displayArcBoundedBy:boundingBox startAngle:startAngle sweepAngle:sweepAngle at:origin

   "draw an arc/circle/ellipse - ST-80 compatibility"                                

   ^ self displayArcX:(boundingBox left + origin x)

		    y:(boundingBox top + origin y)

		width:(boundingBox width)

	       height:(boundingBox height)

		 from:startAngle

		angle:sweepAngle

!

displayWedgeBoundedBy:boundingBox startAngle:startAngle sweepAngle:sweepAngle at:origin

   "fill an arc/circle/ellipse - ST-80 compatibility"

   ^ self fillArcX:(boundingBox left + origin x)

		 y:(boundingBox top + origin y)

	     width:(boundingBox width)

	    height:(boundingBox height)

	      from:startAngle

	     angle:sweepAngle

! !

!GraphicsContext methodsFor:'bit blitting'!

copyFrom:aGC x:srcX y:srcY toX:dstX y:dstY width:w height:h

    "copy from a drawable - maybe self"