"

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

"

DeviceWorkstation subclass:#WinWorkstation

	instanceVariableNames:'blackpixel whitepixel

		listOfFonts rootWin rootDC

		buttonsPressed eventTrace

		eventBuffer

		usingSystemPalette

		resizeFrameWidth resizeFrameHeight'

	classVariableNames:'RawKeysymTranslation BeepFrequency BeepDuration'

	poolDictionaries:''

	category:'Interface-Graphics'

!

!WinWorkstation primitiveDefinitions!

%{

# undef INT

# define INT WIN_INT

# undef Array

# define Array WIN_Array

# undef Number

# define Number WIN_Number

# undef Method

# define Method WIN_Method

# undef Point

# define Point WIN_Point

# undef Rectangle

# define Rectangle WIN_Rectangle

# undef True

# define True WIN_True

# undef False

# define False WIN_False

# undef Block

# undef xxCONTEXT

# define xxCONTEXT        WIN_CONTEXT

# undef _xxCONTEXT

# define _xxCONTEXT       _WIN_CONTEXT

#include <stdio.h>

/* #include <malloc.h> */

/* #include <math.h> */

/* #include <string.h> */

#include <stdarg.h>

/* #include <h/windows.h> */

#  include <windef.h>

#  include <winbase.h>

#  include <wingdi.h>

#  include <winuser.h>

#   ifdef __DEF_Array

#    undef Array

#    define Array __DEF_Array

#   endif

#   ifdef __DEF_Number

#    undef Number

#    define Number __DEF_Number

#   endif

#   ifdef __DEF_Method

#    undef Method

#    define Method __DEF_Method

#   endif

#   ifdef __DEF_Point

#    undef Point

#    define Point __DEF_Point

#   endif

#   ifdef __DEF_Block

#    define Block __DEF_Block

#   endif

/*

 * some defines - tired of typing ...

 */

#define _HANDLEVal(o)        (HANDLE)(__MKCP(o))

#define _HBITMAPVAL(o)       (HBITMAP)(__MKCP(o))

#define _HWNDVal(o)          (HWND)(__MKCP(o))

#define _HPALETTEVal(o)      (HPALETTE)(__MKCP(o))

#define _HCURSORVal(o)       (HCURSOR)(__MKCP(o))

#define _HGDIOBJVal(o)       (HGDIOBJ)(__MKCP(o))

#define _LOGPALETTEVal(o)    (LOGPALETTE *)(__MKCP(o))

#define _COLORREFVal(o)      (COLORREF)(__MKCP(o))

#define _GCDATA(o)           ((struct gcData *)(__MKCP(o)))

#define _HDCVal(o)           (_GCDATA(o)->hDC)

#define _HPENVal(o)          (_GCDATA(o)->hPen)

#define _HBRUSHVal(o)        (_GCDATA(o)->hBrush)

#define __rootDC             (HDC)(__MKCP(__INST(rootDC)))

#define ISCONNECTED          (__INST(rootDC) != nil)

struct gcData {

    HDC         hDC;

    HPEN        hPen;

    HBRUSH      hBrush;

    COLORREF    fgColor;

    COLORREF    bgColor;

    int         brushType;

    int         lineWidth;

    int         lineStyle;

    int         joinStyle;

    int         capStyle;

    int         fontAscent;

};

/*

 * some synthetic values

 */

# define Button1MotionMask      1

# define Button2MotionMask      2

# define Button3MotionMask      4

# define Button1Mask            Button1MotionMask

# define Button2Mask            Button2MotionMask

# define Button3Mask            Button3MotionMask

# define ControlMask            8

# define ShiftMask              16

# define LeftAltMask            32

# define RightAltMask           64

# define TRANSLATED_KEY         256

int AltMask = RightAltMask;

int MetaMask = LeftAltMask;

# define WhitePixel     RGB(0xFF, 0xFF, 0xFF)

# define BlackPixel     RGB(0, 0, 0)

#ifdef DEBUG

# define DPRINTF(x)             printf x

# define DDPRINTF(x)            /* nothing */

# define EVENT_PRINTF(x)        printf x

# define EVENT_PRINTF1(x)       /* */

# define EVENT_PRINTF2(x)       printf x

#else

# define DPRINTF(x)             /* */

# define DDPRINTF(x)            /* */

# define EVENT_PRINTF(x)        /* */

# define EVENT_PRINTF1(x)       /* */

# define EVENT_PRINTF2(x)       /* */

#endif

# define BR_SOLID       0

# define BR_PATTERN     1

# define LINE_SOLID     0

# define LINE_DASH      1

# define LINE_DDASH     2

# define _C_ARROW       1

# define _C_CROSS       2

# define _C_IBEAM       3

# define _C_ICON        4

# define _C_NO          5

# define _C_SIZE        6

# define _C_SIZEALL     7

# define _C_SIZENESW    8

# define _C_SIZENS      9

# define _C_SIZENWSE    10

# define _C_UPARROW     11

# define _C_WAIT        12

static HCURSOR H_C_ARROW = (HCURSOR)0;

static HCURSOR H_C_CROSS = (HCURSOR)0;

static HCURSOR H_C_IBEAM = (HCURSOR)0;

static HCURSOR H_C_ICON = (HCURSOR)0;

static HCURSOR H_C_NO = (HCURSOR)0;

static HCURSOR H_C_SIZE = (HCURSOR)0;

static HCURSOR H_C_SIZEALL = (HCURSOR)0;

static HCURSOR H_C_SIZENESW = (HCURSOR)0;

static HCURSOR H_C_SIZENS = (HCURSOR)0;

static HCURSOR H_C_SIZENWSE = (HCURSOR)0;

static HCURSOR H_C_UPARROW = (HCURSOR)0;

static HCURSOR H_C_WAIT = (HCURSOR)0;

static int evRootX, evRootY;

static HWND buttonWindow = (HWND)0;

%}

! !

!WinWorkstation primitiveVariables!

%{

static HANDLE hInstance = (HANDLE)0, 

	  hPrevInstance = (HANDLE)0;

static int firstInstance = 1;

static char *app_name = "ST/X";

static int __debug__ = 0;

static int __inCreate = 0;

static int create_topView;

static int create_minWidth;

static int create_maxWidth;

static int create_minHeight;

static int create_maxHeight;

%}

! !

!WinWorkstation primitiveFunctions!

%{

struct queuedEvent {

	struct queuedEvent     *ev_next;

	HWND                    ev_hWnd;

	UINT                    ev_message;

	UINT                    ev_wParam;

	int                     ev_arg1;

	int                     ev_arg2;

	int                     ev_arg3;

	int                     ev_arg4;

	int                     filler;

};

#define ev_x    ev_arg1

#define ev_y    ev_arg2

#define ev_w    ev_arg3

#define ev_h    ev_arg4

#define ev_keyCode   ev_wParam

#define ev_scanCode  ev_arg3

#define ev_modifiers ev_arg4

#define EV_CHUNK_SZ     1024

#define EV_CHUNK_CNT    (1024/sizeof(struct queuedEvent))

struct queuedEvent *eventFreeList = (struct queuedEvent *)0;

struct queuedEvent *eventQueueHead = (struct queuedEvent *)0;

struct queuedEvent *eventQueueTail = (struct queuedEvent *)0;

static

enqEvent(hWnd, message, wParam, arg1, arg2, arg3, arg4)

    HWND hWnd;

    UINT message;

    UINT wParam;

{

    struct queuedEvent *ev;

    struct queuedEvent *bulk;

    int i;

    ev = eventFreeList;

    if (ev) {

	eventFreeList = ev->ev_next;

    } else {

	bulk = (struct queuedEvent *) malloc(EV_CHUNK_SZ);

	for (i=1; i<EV_CHUNK_CNT; i++) {

	    bulk[i-1].ev_next = &(bulk[i]);

	}

	bulk[EV_CHUNK_CNT-1].ev_next = (struct queuedEvent *)0;

	ev = bulk;

	eventFreeList = &(bulk[1]);

    }

    ev->ev_next = (struct queuedEvent *)0;

    ev->ev_hWnd = hWnd;

    ev->ev_message = message;

    ev->ev_wParam = wParam;

    ev->ev_arg1 = arg1;

    ev->ev_arg2 = arg2;

    ev->ev_arg3 = arg3;

    ev->ev_arg4 = arg4;

    if (eventQueueTail) {

	eventQueueTail->ev_next = ev;

    } else {

	eventQueueHead = ev;

    }

    eventQueueTail = ev;

}

static

struct queuedEvent *

deqEvent() {

    struct queuedEvent *ev;

    ev = eventQueueHead;

    if (ev) {

	eventQueueHead = ev->ev_next;

	if (! eventQueueHead) {

	    eventQueueTail = (struct queuedEvent *)0;

	}

    }

    return ev;

}

static

freeEvent(ev)

    struct queuedEvent *ev;

{

    ev->ev_next = eventFreeList;

    eventFreeList = ev;

}

static

getModifiers()

{

    int modifiers;

    modifiers = 0;

    if (GetKeyState(VK_SHIFT) & 0x8000)

	modifiers |= ShiftMask;

    if (GetKeyState(VK_CONTROL) & 0x8000)

	modifiers |= ControlMask;

    if (GetKeyState(VK_RMENU) & 0x8000)

	modifiers |= RightAltMask;

    if (GetKeyState(VK_LMENU) & 0x8000)

	modifiers |= LeftAltMask;

    if (GetKeyState(VK_LBUTTON) & 0x8000)

	modifiers |= Button1Mask;

    if (GetKeyState(VK_MBUTTON) & 0x8000)

	modifiers |= Button2Mask;

    if (GetKeyState(VK_RBUTTON) & 0x8000)

	modifiers |= Button3Mask;

    return modifiers;

}

static

getAllWinEvents()

{

    MSG msg;

    int more;

    if (PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE)) {

	more = 1;

	while (more) {

	    GetMessage(&msg, (HWND)0, 0, 0);

	    if ((msg.message == WM_KEYDOWN) || (msg.message == WM_KEYUP)

	     || (msg.message == WM_SYSKEYDOWN) || (msg.message == WM_SYSKEYUP)) {

		if (((msg.wParam >= '0') && (msg.wParam <= 'Z'))

		 || (msg.wParam == 0x20)

		 || (msg.wParam >= 0xB0)) {

		    /* 

		     * translate to a WM_CHAR message

		     */

		    if (TranslateMessage(&msg))

			continue;

		}

	    }

	    evRootX = msg.pt.x;

	    evRootY = msg.pt.y;

	    DispatchMessage(&msg);

	    more = PeekMessage(&msg, (HWND)0, 0, 0, PM_NOREMOVE);

	}

    }

}

static

winEventProcessing(hWnd, message, wParam, lParam, pDefault)

    HWND hWnd;                /* window handle                   */

    UINT message;             /* type of message                 */

    UINT wParam;              /* additional information          */

    LONG lParam;              /* additional information          */

    int *pDefault;

{

    LPMINMAXINFO lpmmi;

    WINDOWPOS *posStruct;

    int modifiers;

    int x, y, w, h;

/*

    EVENT_PRINTF(("winEvent hWin=0x%x message=0x%x wP=0x%x lP=0x%x\n", 

			hWnd, message, wParam, lParam));

*/

    /*

     * messages which are handled right here 

     */

    if (__inCreate) {

	EVENT_PRINTF(("in create\n"));

	switch (message) {

	    case WM_GETMINMAXINFO:

		if (create_topView) {

		    lpmmi = (LPMINMAXINFO) lParam;

		    DPRINTF(("WM_GETMINMAXINFO handle=%x got min: %d/%d\n",

				hWnd,

				lpmmi->ptMinTrackSize.x,

				lpmmi->ptMinTrackSize.y));

		    lpmmi->ptMaxSize.x = create_maxWidth;

		    lpmmi->ptMaxSize.y = create_maxHeight;

		    lpmmi->ptMaxTrackSize.x = create_maxWidth;

		    lpmmi->ptMaxTrackSize.y = create_maxHeight;

		    lpmmi->ptMinTrackSize.x = create_minWidth;

		    lpmmi->ptMinTrackSize.y = create_minHeight;

		    DPRINTF(("WM_GETMINMAXINFO handle=%x return min: %d/%d max: %d/%d\n", 

				    hWnd,

				    create_minWidth, create_minHeight,

				    create_maxWidth, create_maxHeight));

		    *pDefault = 0;

		    return 0;

		}

		break;

	}

    }

    /*

     * messages which are enqueued to be handled by the view thread

     */

    switch (message) {

	case WM_SETCURSOR:

	    *pDefault = 1;

	    return 0;

	case WM_WINDOWPOSCHANGED:

	    EVENT_PRINTF(("WM_WINDOWPOSCHANGED\n"));

	    posStruct = (WINDOWPOS *)lParam;

	    if (! posStruct) {

		DPRINTF(("oops - no posStruct passed\n"));

		break;

	    }

	    {

		RECT rct;

		GetClientRect(hWnd, &rct);

		enqEvent(hWnd, message, wParam,

			       rct.left, rct.top,

			       rct.right-rct.left+1,

			       rct.bottom-rct.top+1);

	    }

#if 0

	    enqEvent(hWnd, message, wParam,

			   posStruct->x, posStruct->y, 

			   posStruct->cx, posStruct->cy);

#endif

	    *pDefault = 0;

	    return 0;

	case WM_ERASEBKGND:

	    EVENT_PRINTF(("WM_ERASEBKGND\n"));

	    goto paint;

	case WM_PAINT:

	    EVENT_PRINTF(("WM_PAINT\n"));

	paint:

	    {

		RECT upd;

		if (GetUpdateRect(hWnd, &upd, 0)) {

		    if ((upd.left == upd.right) && (upd.top == upd.bottom)) {

			DPRINTF(("WM_PAINT: null rectangle\n"));

			ValidateRect(hWnd, NULL);

			break;

		    }

		    x = upd.left;

		    y = upd.top;

		    w = upd.right - upd.left + 1;

		    h = upd.bottom - upd.top + 1;

		    ValidateRect(hWnd, NULL);

		    enqEvent(hWnd, message, wParam, x, y, w, h);

		    *pDefault = 0;

		    return 0;

		}

	    }

	    *pDefault = 0;

	    return 0;

	    break;

	case WM_SHOWWINDOW:

	    EVENT_PRINTF(("WM_SHOWWINDOW\n"));

	    enqEvent(hWnd, message, wParam, 0, 0, 0, 0);

	    *pDefault = 0;

	    return 0;