"

 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:'foreground background paint bgPaint

                              function font

                              lineStyle lineWidth

                              joinStyle capStyle

                              mask maskOrigin'

       classVariableNames:'White Black' 

       poolDictionaries:''

       category:'Graphics-Display Objects'

!

GraphicsContext comment:'

COPYRIGHT (c) 1992 by Claus Gittinger

              All Rights Reserved

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

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

this class.

Drawing is done somewhat silly (due to beeing both backward compatible

and supporting ST-80 messages). The paint instance describes the paint

color, which can be (on monos) a dither pixmap drawn in foreground/background

colors.

Foreground and background are the underlying basic-colors, which must be

real colors (i.e. non dithered). Direct access to fg/bg is discouraged, since

in the future, foreground / background will be totally replaced by

paint.

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

foreground      <Color>         the device foreground color used for drawing

background      <Color>         the device background color used for drawing

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 font currently 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

Class instance variables:

DefaultFont     <Font>          default font to use

written summer 92 by claus

'!

GraphicsContext class instanceVariableNames:'DefaultFont'!

!GraphicsContext class methodsFor:'initialization'!

initialize

    "setup some defaults - these are usually redefined

     during startup."

    Color isNil ifTrue:[^ self].

    Color initialize.

    White := Color white.

    Black := Color black.

    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

! !

!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

    ^ self basicNew initialize

! !

!GraphicsContext methodsFor:'initialization'!

initialize

    "set up some useful default values"

    "default is drawing black-on-white;

     since these two colors are needed very often, cache them here"

    White isNil ifTrue:[White := Color white].

    Black isNil ifTrue:[Black := Color black].

    paint := Black.

    bgPaint := White.

    foreground := Black.

    background := White.

    function := #copy.

    lineWidth := 1.

    lineStyle := #solid.

    joinStyle := #miter.

    capStyle := #butt.

    self initFont

!

initFont

    |aFont|

    aFont := self class defaultFont.

    "this is a kludge"

    aFont isNil ifTrue:[

        self class initialize.

        aFont := self class defaultFont.

    ].

    aFont notNil ifTrue:[

        font := aFont

    ]

! !

!GraphicsContext methodsFor:'misc'!

flush

    "st-80 compatibility"

    ^ self

! !

!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"

    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

!

foreground

    "return the current foreground drawing color"

    ^ foreground

!

foreground:aColor

    "set the drawing foreground color.

     aColor MUST be a real (i.e. device-) color"

    foreground := aColor

!

background

    "return the current background drawing color"

    ^ background

!

background:aColor

    "set the drawing background color.

     aColor MUST be a real (i.e. device-) color"

    background := aColor

!

function

    "return the current drawing function"

    ^ function

!

function:aFunctionSymbol

    "set the drawing function"

    ^ self subclassResponsibility

!

foreground:fgColor background:bgColor 

    "set both foreground and background colors"

    self foreground:fgColor.

    self background:bgColor

!

foreground:fgColor background:bgColor function:f

    "set foreground, background colors and function"

    self foreground:fgColor.

    self background:bgColor.

    self function:f

!

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:aRectangle

    "set the drawing clip-rectangle"

    ^ self subclassResponsibility

!

graphicsContext

    "for ST-80 compatibility"

    ^ self

!

viewOrigin

    "return the drawables visible origin (for scrolling)"

    ^ 0@0

!

setMaskOrigin:aPoint

    ^ self

!

setMaskOriginX:x y:y

    ^ self

!

withPattern:aForm do:aBlock

    'pattern drawing not implemented' printNewline.

    aBlock value

! !

!GraphicsContext methodsFor:'displaying'!

displayRectangularBorder:aRectangle at:aPoint

    "draw a rectangle - ST-80 compatibility"

    self drawRectangle:(aRectangle translateBy:aPoint)

!

displayLineFrom:startPoint to:endPoint translateBy:anOffset

    "draw a line - ST-80 compatibility"

    self displayLineFrom:(startPoint + anOffset)

                      to:(endPoint + anOffset)

!

displayRectangle:aRectangle

    "draw a rectangle - ST-80 compatibility"

    ^ self drawRectangle:aRectangle

!

displayPolyline:aPolygon

    "draw a polygon - ST-80 compatibility"

    |p|

    p := aPolygon collect:[:p | p x rounded @ p y rounded ].

    self drawPolygon:p 

!

displayPolygon:aPolygon

    "draw a filled polygon - ST-80 compatibility"

    |p|

    p := aPolygon collect:[:p | p x rounded @ p y rounded ].

    self fillPolygon:p 

! !

!GraphicsContext methodsFor:'bit-blitting'!

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

    "copy from a drawable - maybe self"

    ^ self subclassResponsibility

!

copyFrom:aGraphicContext x:dstX y:dstY width:w height:h

    "copy from a drawable - maybe self"

    self copyFrom:aGraphicContext x:0 y:0 toX:dstX y:dstY width:w height:h

! !

!GraphicsContext methodsFor:'basic filling'!

fillPolygon:points

    "fill a polygon with current paint color"

    ^ self subclassResponsibility

!

fillRectangleX:x y:y width:w height:h

    "fill a rectangle with current paint color"

    ^ self subclassResponsibility

!

fillArcX:x y:y w:w h:h from:start angle:angle

    "fill an arc with current paint color"

    ^ self subclassResponsibility

! !

!GraphicsContext methodsFor:'filling'!

fillRectangle:aRectangle

    "fill a rectangle with current paint color"

    self fillRectangleX:(aRectangle left)

                      y:(aRectangle top)

                  width:(aRectangle width)

                 height:(aRectangle height)

!

fillCircle:aPoint radius:aNumber

    "draw a filled circle"

    self fillCircleX:(aPoint x) y:(aPoint y) radius:aNumber

!

fillCircleX:x y:y radius:r

    "draw a filled circle"

    |d|

    d := 2 * r.

    self fillArcX:(x - r) y:(y - r) w:d  h:d from:0 angle:360

! !

!GraphicsContext methodsFor:'basic drawing'!

drawPolygon:aPolygon

    "draw a polygon

     - this could be recoded to draw using displayLine"

    ^ self subclassResponsibility

!

displayArcX:x y:y w:width h:height from:startAngle angle:angle

    "draw an arc in a box

     - this could be recoded to draw using displayLine"

    ^ self subclassResponsibility

!

drawRectangleX:x y:y width:w height:h

    "draw a rectangle

     - this could be recoded to draw using displayLine"

    ^ self subclassResponsibility

!