"

COPYRIGHT (c) 1993 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.

"

HostGraphicsDevice subclass:#DeviceWorkstation

	instanceVariableNames:'visualType monitorType depth ncells bitsPerRGB bitsRed bitsGreen

		bitsBlue redMask greenMask blueMask redShift greenShift blueShift

		hasColors hasGreyscales width height widthMM heightMM

		resolutionHor resolutionVer idToViewMapping knownViews knownIds

		knownBitmaps knownBitmapIds dispatching dispatchProcess ctrlDown

		shiftDown metaDown altDown motionEventCompression lastId lastView

		keyboardMap rootView isSlow activeKeyboardGrab activePointerGrab

		buttonTranslation multiClickTimeDelta altModifiers metaModifiers

		ctrlModifiers shiftModifiers supportsDeepIcons preferredIconSize

		ditherColors fixColors numFixRed numFixGreen numFixBlue

		copyBuffer lastCopyBuffer blackColor whiteColor'

	classVariableNames:'ButtonTranslation MultiClickTimeDelta DeviceErrorSignal

		ErrorPrinting DefaultScreen AllScreens ExitOnLastClose

		CurrentScreenQuerySignal LastActiveScreen LastActiveProcess'

	poolDictionaries:''

	category:'Interface-Graphics'

!

!DeviceWorkstation class methodsFor:'documentation'!

copyright

"

COPYRIGHT (c) 1993 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.

"

!

documentation

"

    this abstract class defines common protocol to all Display types.

    For compatibility with ST-80, this class (actually a concrete subclass) 

    is also bound to the global variable Screen.

    DeviceWorkstation (and its concrete subclasses) are the central classes

    around windowManagement and event processing.

    See the documentation in #events and #workstationDevices for more detailed

    info.

    [instance variables:]

      displayId       <Number>          the device id of the display

      visualType      <Symbol>          one of #StaticGray, #PseudoColor, ... #TrueColor

      monitorType     <Symbol>          one of #monochrome, #color, #unknown

      depth           <SmallInteger>    bits per color

      ncells          <SmallInteger>    number of colors (i.e. colormap size; not always == 2^depth)

      bitsPerRGB      <SmallInteger>    number of valid bits per rgb component

                                        (actual number taken in A/D converter; not all devices report the true value)

      bitsRed         <SmallInteger>    number of red bits (only valid for TrueColor displays)

      bitsGreen       <SmallInteger>    number of green bits (only valid for TrueColor displays)

      bitsBlue        <SmallInteger>    number of blue bits (only valid for TrueColor displays)

      redMask         <SmallInteger>    shifted red mask (only useful for TrueColor displays)

      greenMask       <SmallInteger>    shifted green mask (only useful for TrueColor displays)

      blueMask        <SmallInteger>    shifted blue mask (only useful for TrueColor displays)

      shiftRed        <SmallInteger>    number of bits to shift red bits (only valid for TrueColor displays)

      shiftGreen      <SmallInteger>    number of bits to shift green bits (only valid for TrueColor displays)

      shiftBlue       <SmallInteger>    number of bits to shift blue bits (only valid for TrueColor displays)

      hasColors       <Boolean>         true, if display supports colors

      hasGreyscales   <Boolean>         true, if display supports grey-scales (i.e is not b/w display)

      width           <SmallInteger>    number of horizontal pixels

      height          <SmallInteger>    number of vertical pixels 

      heightMM        <Number>          screen height in millimeter

      widthMM         <Number>          screen width in millimeter

      resolutionHor   <Number>          pixels per horizontal millimeter

      resolutionVer   <Number>          pixels per vertical millimeter

      idToViewMapping <Dictionary>      maps view-ids to views

      knownViews      <WeakArray>       all of my known views

      knownIds        <Collection>      corresponding device-view ids

      knownBitmaps    <Collection>      all known device bitmaps

      knownBitmapIds  <Collection>      corresponding device-bitmap ids

      dispatching     <Boolean>         true, if currently in dispatch loop

      ctrlDown        <Boolean>         true, if control key currently pressed

      shiftDown       <Boolean>         true, if shift key currently pressed

      metaDown        <Boolean>         true, if meta key (cmd-key) is currently pressed

      altDown         <Boolean>         true, if alt key is currently pressed

      motionEventCompression

                      <Boolean>         if true motion events are compressed

                                        (obsolete: now done in sensor)

      lastId          <Number>          the id of the last events view (internal)

      lastView        <View>            the last events view (internal, for faster id->view mapping)

      keyboardMap     <KeyBdMap>        mapping for keys

      rootView        <DisplayRootView> this displays root window

      isSlow          <Boolean>         set/cleared from startup - used to turn off

                                        things like popup-shadows etc.

    [class variables:]

      MultiClickTimeDelta               in ms; controls how long of a delay is

                                        required between two clicks, to NOT take

                                        it as a multi-click.

      ErrorPrinting                     controls low-level (X-) error message printing

      AllScreens                        a collectin of known screens

      ExitOnLastClose                   if true, the dispatch process terminates when the

                                        last view is closed. (for stand alone apps)

                                        Should be set to false, if a standAlone app

                                        closes all views and still needs an event dispatcher

                                        later (i.e. is temporary view-less)

    [see also:]

        GraphicsContext DeviceDrawable

        WindowSensor WindowGroup WindowEvent

        ProcessorScheduler

        PSMedium

    [author:]

        Claus Gittinger

"

!

events

"

    All events are processed in a workstations dispatchEvent method.

    There, incoming events are first sent to itself, for a first (view independent)

    preprocessing. For example, the devices state of the shift-, alt-, control and

    meta keys are updated there. After that, the event is forwarded either to

    the views sensor or to the view directly (if it has no sensor).

    (Sensorless views are a leftover from ancient times and will sooner or

     later vanish - simplifying things a bit. Do not depend on views without

     sensors to work correctly in future versions.)

    This event processing is done by the event dispatcher process, which is

    launched in ST/X's startup sequence (see Smalltalk>>start).

    Event processing is done at a high priority, to allow keyboad processing

    and CTRL-C handling to be performed even while other processes are running.

    The code executed by the event process is found in startDispatch.

    Individual events can be enabled or disabled. The ones that are enabled

    by default are:

        keypress / keyRelease

        buttonPress / buttonRelease / buttonMotion (i.e. motion with button pressed)

        pointerEnter / pointerLeave

    other events have to be enabled by sending a corresponding #enableXXXEvent

    message to the view which shall receive those events.

    For example, pointerMotion events (i.e. motion without button being pressed)

    are enabled by: 'aView enableMotionEvent'

    The above is only of interest, if you write your own widget classes,

    existing widgets set things as required in their #initEvents method.

"

!

workstationDevices

"

    In ST/X, all interaction with the graphics device is done through

    an instance of (a subclass) of DeviceWorkstation.

    Every view has a reference to the device it has been created on in

    its 'device' instance variable. 

    One particular device instance is bound to the global variable Display:

    this is the default graphics display, on which new views are created

    (however, provisions exist for multi-display operation)

    Currently, there is are only two concrete display classes (released to the public):

        XWorkstation    - a plain X window interface

        GLXWorkstation  - an X window interface with a GL(tm) (3D graphic library) 

                          extension; either simulated (VGL) or a real GL 

                          (real GL is only available on SGI machines)

    the following are coming soon:

        OpenGLWorkstation   

                        - an X window interface with a openGL(tm) (3D graphic library) 

                          extension; either simulated (MESA) or a real openGL 

                          (real openGL is only available on SGI/NT machines)

        WinWorkstation  - what will that be ?

    An experimental version for a NeXTStep interface exists, but is currently

    no longer maintained and not released.

    Also, interfaces for other graphic systems (i.e. OS/2) are

    planned for and will be available (hopefully) in late 96.

    DeviceWorkstation itself is an abstract class; the methods as defined

    here perform things which are common to all graphic devices or block

    methods and raise a subclassResponsibilty error condition.

    To create a new graphic interface, at least the subclassResponsibilty-methods

    have to be reimplemented in a concrete subclass.

    ST/X is designed to allow the use of multiple workstation devices in parallel, if

    the underlying window system supports this.

    For example, in X, it is possible to create another instance of XWorkstation, 

    start a dispatch process for it, and to create and open views on this display. 

    This does not work with other devices (i.e. Windows).

    If you want to experiment with multi-display applications,

    you have to:

        - create a new instance of XWorkstation:

            Smalltalk at:#Display2 put:(XWorkstation new).

          or:

            Smalltalk at:#Display2 put:(GLXWorkstation new).

        - have it connect to the display (i.e. the xServer):

          (replace 'localhost' below with the name of your display)

            Display2 := Display2 initializeFor:'localhost:0.0'

          returns nil, if connection is refused 

          - leaving you with Display2==nil in this case.

        - start an event dispatcher process for it:

          (this is now no longer needed - the first opened view will do it for you)

            Display2 startDispatch

        - optionally set its keyboard map

          (since this is usually done for Display in the startup-file,

           the new display does not have all your added key bindings)

            Display2 keyboardMap:(Display keyboardMap)

        - create a view for it:

            (FileBrowser onDevice:Display2) open

            (Workspace onDevice:Display2) open

            (Launcher onDevice:Display2) open

                does not work with Launcher, since its an ApplicationModel (not a view)

                use:

                    Launcher openOnDevice:Display2

                instead.

    However, as mentioned above, there may be a few places, where the default

    display 'Display' is still hard-coded - especially, in contributed and

    Public domain code, you may find those.

    Beside this (little bug ;-), remote display operation works pretty well. 

    If you write your application to work around those, multi-display applications are

    possible in the current release.

    To make your application ready for multi-display operation, replace all

    references to 'Display' by: 'Screen current', which evaluates to the currently

    active display. I.e. each view gets its actual display via this expression.

    Since ST/X views already use this, new views opened by remote views should

    come up on the remote display.

    There is no easy solution for things like Notifiers, WarnBoxes or

    Debuggers when opened from some background or non-view process.

    These will come up one the default Display, as returned by 'Screen default'.

    There may still some problems to be expected,

    if the screens have different display capabilities (b&w vs. greyscale vs.

    color display). The current styleSheet approach keeps default values

    only once (it should do so per display ...) For now, expect ugly looking

    views in this case - or set your styleSheet for the smallest common 

    capabilities (i.e. for b&w).

"

! !

!DeviceWorkstation class methodsFor:'initialization'!

initialize

    "create local error signals; enable errorPrinting"

    DeviceErrorSignal isNil ifTrue:[

        DeviceErrorSignal := (Signal new) mayProceed:true.

        DeviceErrorSignal notifierString:'device error'.

        CurrentScreenQuerySignal := QuerySignal new.

        CurrentScreenQuerySignal nameClass:self message:#currentScreenQuerySignal.

        CurrentScreenQuerySignal notifierString:'asking for current screen'.

    ].

    ErrorPrinting := true.

    ExitOnLastClose := false.

    self initializeConstants.

    "Modified: 15.2.1997 / 15:08:40 / cg"

!

initializeConstants

    "initialize some (soft) constants"

    MultiClickTimeDelta := 300.       "a click within 300ms is considered a double one"

    ButtonTranslation := #(1 2 3)     "identity translation"

! !

!DeviceWorkstation class methodsFor:'Signal constants'!

currentScreenQuerySignal

    "return the signal which can be used to provide a current

     screen (if background processes ask for one)"

    ^ CurrentScreenQuerySignal

    "Created: 15.2.1997 / 15:07:20 / cg"

!

deviceErrorSignal

    "return the signal used for device error reporting"

    ^ DeviceErrorSignal

! !

!DeviceWorkstation class methodsFor:'accessing'!

buttonTranslation:anArray

    "set the button translation, #(1 2 3) is no-translation,

     #(3 2 1) is ok for left-handers"

    ButtonTranslation := anArray.

    Display notNil ifTrue:[

        Display buttonTranslation:anArray

    ].

! !

!DeviceWorkstation class methodsFor:'error handling'!

errorInterrupt:errID with:aParameter

    "{ Pragma: +optSpace }"

    "an error in the devices low level code (typically Xlib or XtLib)

     This is invoked via 

        XError->errorInterrupt:#DisplayError->registeredErrorInterruptHandlers

     looks if a signal handler for DeviceErrorSignal is present,

     and - if so raises the signal. If the signal not handled, simply output a

     message and continue.

     This allows for non disrupted error reporting OR to catch and

     investigate errors as required."

    |badId badResource msg|

    badId := self resourceIdOfLastError.

    badId ~~ 0 ifTrue:[

        badResource := self resourceOfId:badId.

    ].

    msg := 'Display error: ' , (self lastErrorString).

    DeviceErrorSignal isHandled ifFalse:[

        ErrorPrinting ifTrue:[

            ('DeviceWorkstation [error]: ' , msg) errorPrintCR

        ].

        ^ self

    ].

    ^ DeviceErrorSignal

            raiseRequestWith:badResource 

            errorString:msg

    "Modified: 10.1.1997 / 17:48:06 / cg"

!

errorPrinting

    "return the `errorPrinting-is-on' flag"

    ErrorPrinting isNil ifTrue:[^ false].

    ^ ErrorPrinting

    "Modified: 24.4.1996 / 19:35:55 / cg"

!

errorPrinting:aBoolean

    "set/clear the `errorPrinting-is-on' flag"

    ErrorPrinting := aBoolean

    "Modified: 24.4.1996 / 19:36:02 / cg"

!

lastErrorString

    "return a string describing the last error"

    ^ self subclassResponsibility

!

resourceIdOfLastError

    "return the resource id responsible for the last error"

    ^ self subclassResponsibility

!

resourceOfId:id

    "{ Pragma: +optSpace }"

    "search thru all device stuff for a resource.

     Needed for error handling"

    Form allInstances do:[:f |

        f id == id ifTrue:[^ f]

    ].

    self allInstances do:[:aDisplay |

        aDisplay allViewsDo:[:aView |

            aView id == id ifTrue:[^ aView].

            aView gcId == id ifTrue:[^ aView]

        ].

"/        |views|

"/        views := aDisplay knownViews.

"/        views notNil ifTrue:[

"/            views do:[:v |

"/                v id == id ifTrue:[^ v].

"/                v gcId == id ifTrue:[^ v]

"/            ].

"/        ].

    ].

    Color allInstances do:[:c |

        c colorId == id ifTrue:[^ c]

    ].

    Font allInstances do:[:f |

        f fontId == id ifTrue:[^ f]

    ].

    ^ nil

    "Modified: 24.4.1996 / 19:36:15 / cg"

! !

!DeviceWorkstation class methodsFor:'queries'!

allScreens

    "Return a collection of active display devices.

     Typically, there is only one: Display or Screen current."

    ^ AllScreens

    "

     Screen allScreens  

    "

    "Modified: 1.9.1995 / 13:38:35 / claus"

    "Modified: 24.4.1996 / 19:36:59 / cg"

!

current

    "Return the currently active screen,

     that is, the device of the currently executing windowGroup.

     It will be used in multi-display operation, to launch views on

     the correct device - even if not specified explicitely.

     This does not yet work fully satisfying if a background processes

     invokes this ... the default display is returned in this case."

    |wg dev thisProcess|

    "/

    "/ if there is only one screen,

    "/ take that ... it ought to be display

    "/

    AllScreens size <= 1 ifTrue:[

        ^ Display

    ].

    "/

    "/ someone willing to tell me ?

    "/

    (dev := CurrentScreenQuerySignal raise) notNil ifTrue:[

        ^ dev