The R Project SVN – R – Diff – /trunk/src/gnuwin32/graphapp/events.c


/*
 * GraphApp - Cross-Platform Graphics Programming Library.
 *
 * File: events.c -- winprocs and timers are contained here.
 * Platform: Windows  Version: 2.35  Date: 1998/04/04
 *
 * Version: 1.00  Changes: Original version by Lachlan Patrick.
 * Version: 2.00  Changes: New class system implemented.
 * Version: 2.20  Changes: Non-native buttons supported.
 * Version: 2.22  Changes: 32-bit fix by Wim Rijnders.
 * Version: 2.35  Changes: New delayed deletion technique.
 */
 
/* Copyright (C) 1993-1998 Lachlan Patrick
 
   This file is part of GraphApp, a cross-platform C graphics library.
 
   GraphApp is free software; you can redistribute it and/or modify it
   under the terms of the GNU Library General Public License.
   GraphApp is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.
 
   See the file COPYLIB.TXT for details.
*/
 
#include "internal.h"
 
/*
 *  Library variables.
 */
	static timerfn do_timer = NULL;
	static void *timer_data = NULL;
 
	static MSG    msg;
	PROTECTED int keystate = 0; /* state of shift, ctrl and alt keys */
 
/* a user-timer and a mouse-down timer function can be started */
 
	static	UINT	timer_id	= 0;
	static	UINT	mouse_timer_id	= 0;
 
/* buttons and xy are used to record the state of the mouse */
 
	static	int 	buttons = 0;
	static	point	xy;
 
	static	long	mouse_msec = 0;
 
	TIMERPROC app_timer_proc;
	WNDPROC   app_control_proc;
 
	static object frontwindow = NULL; /* the window receiving events */
 
/*
 *  Call the relevent mouse handler function.
 */
static void handle_mouse(object obj, HWND hwnd, UINT message,
			int param, int x, int y)
{
        menu m;
        POINT wp;
        HWND hw;
	int dble = 1;
 
	xy.x = x;
	xy.y = y;
	buttons = 0;
        if (!obj) return;
	if (param & MK_LBUTTON)
		buttons |= LeftButton;
	if (param & MK_MBUTTON)
		buttons |= MiddleButton;
	if (param & MK_RBUTTON)
		buttons |= RightButton;
 
	/* dispatch the mouse event to the relevent handler */
	if (obj && obj->drawstate && obj->drawstate->crsr)
                 SetCursor((HCURSOR)obj->drawstate->crsr->handle);
 
	switch (message)
	{
	case WM_MOUSEMOVE:
                if (obj->call) {
		  if (buttons) {
			if (obj->call->mousedrag)
				obj->call->mousedrag(obj, buttons, xy);
		  }
		  else if (obj->call->mousemove)
			obj->call->mousemove(obj, buttons, xy);
                }
		break;
	case WM_LBUTTONDOWN:
	case WM_RBUTTONDOWN:
	case WM_MBUTTONDOWN:
	        dble = 0;
		setmousetimer(mouse_msec); /* restart timer */
		/* fall through to next case */
	case WM_LBUTTONDBLCLK:
	case WM_RBUTTONDBLCLK:
	case WM_MBUTTONDBLCLK:
	        if (dble) buttons |= DblClick;
		if ((obj->flags & ChildWindow) &&  (obj->kind != LabelObject))
			SetFocus(hwnd);
		if (obj->flags & TrackMouse)
			SetCapture(hwnd);
                if (buttons == RightButton) {
                    m = obj->popup; hw = hwnd;
                    if (!m) {
                        m = obj->parent->popup;
                        hw = (HWND) obj->parent->handle;
                    }
                    if (m) {
                      wp.x = x; wp.y = y;
                      ClientToScreen(hw, (LPPOINT) &wp);
                      if (m->action) m->action(m);
                      TrackPopupMenu(m->handle,
                         TPM_LEFTALIGN|
                         TPM_LEFTBUTTON|TPM_RIGHTBUTTON,
                         wp.x,wp.y,
                         0,
                         obj->handle,
                         NULL);
                         break;
                    }
                }
		if (obj->call && obj->call->mousedown)
			obj->call->mousedown(obj, buttons, xy);
		break;
	case WM_LBUTTONUP:
	case WM_RBUTTONUP:
	case WM_MBUTTONUP:
		if ((obj->flags & TrackMouse) && (buttons == 0))
			ReleaseCapture();
		if (obj->call && obj->call->mouseup)
			obj->call->mouseup(obj, buttons, xy);
		break;
	}
}
 
/*
 *  Some WM_KEYDOWN VK_* messages call the keyaction associated
 *  with a window.
 */
static void handle_virtual_keydown(object obj, int param)
{
	if ((! obj->call) || (! obj->call->keyaction))
		return;
 
	/* translate arrow key combinations into Unicode arrow symbols */
	if ((param >= VK_LEFT) && (param <= VK_DOWN)) {
		param += (LEFT - VK_LEFT);
	}
 
	/* translate functions keys into Unicode circled numbers */
	else if ((param >= VK_F1) && (param <= VK_F10)) {
		param += (F1 - VK_F1);
	}
 
	/* translate other keyboard keys into Unicode 'equivalents' */
	else switch (param) {
		case VK_PRIOR:	param = PGUP; break;
		case VK_NEXT:	param = PGDN; break;
		case VK_END:	param = END;  break;
		case VK_HOME:	param = HOME; break;
		case VK_INSERT:	param = INS;  break;
		case VK_DELETE:	param = DEL;  break;
		default:	return; /* do nothing */
	}
 
	drawto(obj);
	obj->call->keyaction(obj, param);
}
 
static void handle_keydown(int param)
{
        if (param == VK_SHIFT)
		keystate |= ShiftKey;
	else if (param == VK_CONTROL)
		keystate |= CtrlKey;
	else if (param == VK_MENU)
		keystate |= AltKey;
}
 
static void handle_keyup(int param)
{
        if (param == VK_SHIFT)
		keystate &= ~ShiftKey;
	else if (param == VK_CONTROL)
		keystate &= ~CtrlKey;
	else if (param == VK_MENU)
		keystate &= ~AltKey;
}
 
/*
 *  Handle char messages.
 */
static void handle_char(object obj, int ch)
{
	if (obj->call && obj->call->keydown) {
		if (ch == '\r') /* carriage return becomes newline */
			ch = '\n';
		drawto(obj);
		obj->call->keydown(obj, ch);
	}
}
 
static void handle_mdiframesize() {
     HWND tool=NULL ,status=NULL;
     RECT rFrame,rToolbar;
     int  fw, fh, th=0, sh=0;
     GetClientRect(hwndFrame,&rFrame);
     fw = rFrame.right-rFrame.left;
     fh = rFrame.bottom-rFrame.top;
     if (MDIToolbar) {
        tool = (HWND)MDIToolbar->handle;
        GetWindowRect(tool,&rToolbar);
        th = rToolbar.bottom-rToolbar.top;
     }
     if (MDIStatus) {
        status = (HWND)MDIStatus;
        GetWindowRect(status,&rToolbar);
        sh = rToolbar.bottom-rToolbar.top;
     }
     MoveWindow(hwndClient,0,th+1,fw,fh-sh-th-1,TRUE);
     if (tool) {
        MoveWindow(tool,1,0,fw-2,th,TRUE);
        show(MDIToolbar);
     }
     if (status) {
        MoveWindow(status,1,fh-sh,fw-2,sh,TRUE);
     }
     SetFocus((HWND)SendMessage(hwndClient,
                WM_MDIGETACTIVE,(WPARAM)0,(LPARAM) 0));
}
 
/*
 *  The window is being resized for some reason.
 */
static void handle_resize(object obj)
{
	if (obj->call && obj->call->resize) {
		drawto(obj);
		obj->call->resize(obj,
			rect(0,0,obj->rect.width,obj->rect.height));
	}
	deletion_traversal();  /* We may be called again before 
				  returning to doevent */
}
 
/*
 *  The window is being redrawn for some reason.
 */
static void handle_redraw(object obj, HWND hwnd)
{
	PAINTSTRUCT ps;
        if (obj==MDIFrame)
                handle_mdiframesize();
	del_context(obj);
	add_context(obj, BeginPaint(hwnd, &ps), NULL);
	if (ps.fErase)
		clear(obj);
	draw(obj);
	EndPaint(hwnd, &ps);
	remove_context(obj);
	dc = 0;
}
 
/*
 *  Hide an application window, or call close() function if possible.
 */
static void handle_close(object obj)
{
	if (obj->call && obj->call->close) {
		drawto(obj);
		obj->call->close(obj);
	} else {
		hide(obj);
	}
}
 
static void handle_destroy(object obj)
{
	/*
	drawto(obj);
	del_object(obj);
	*/
}
 
static void handle_focus(object obj, int gained_focus)
{
	if (gained_focus)
		obj->state |= Focus;
	else
		obj->state &= ~Focus;
	if ((! USE_NATIVE_BUTTONS) && (obj->kind == ButtonObject))
		InvalidateRect(obj->handle, NULL, 0);
}
 
/*
 *  Handle scrollbars. Designed to also work with normal window
 *  scrollbars.
 */
static void handle_scroll(object obj, HWND hwnd, UINT message,
				WPARAM wParam, LPARAM lParam)
{
	int size_shown = 10;
	int max_value = 100;
	int where = 0;
	int prev = 0;
	/* we need to look at the recorded values */
	max_value = obj->max;
	size_shown = obj->size;
	if (obj->kind != WindowObject) {
		prev = where = GetScrollPos(hwnd, SB_CTL);
	}
	else if (message == WM_VSCROLL) {
		prev = where = GetScrollPos(hwnd, SB_VERT);
	} else if (message == WM_HSCROLL) {
	    prev = where = GetScrollPos(hwnd, SB_HORZ);
	    max_value = obj->xmax;
	    size_shown = obj->xsize;
	}
 
	/* next we look at wParam to see what happened */
	switch(LOWORD(wParam))
	{
	case SB_PAGEDOWN:	where += (size_shown-1);
				/* fall through to next case */
	case SB_LINEDOWN:	where = min(max_value, where+1);
				break;
	case SB_PAGEUP:		where -= (size_shown-1);
				/* fall through to next case */
	case SB_LINEUP:		where = max(0, where-1);
				break;
	case SB_TOP:		where = 0;
				break;
	case SB_BOTTOM:		where = max_value;
				break;
	case SB_THUMBPOSITION:
	case SB_THUMBTRACK:
		#ifdef WIN32
				where = HIWORD(wParam);
		#else
				where = LOWORD(lParam);
		#endif
				break;
	default:		break;
	}
	/* check if something happened */
	if (prev == where)
		return;
	/* now we reset the scrollbar's values */
	if (obj->kind != WindowObject) {
		SetScrollPos(hwnd, SB_CTL, where, 1);
	}
	else if (message == WM_VSCROLL) {
	       SetScrollPos(hwnd, SB_VERT, where, 1);
        }
	else if (message == WM_HSCROLL) {
	       SetScrollPos(hwnd, SB_HORZ, where, 1);
               where = -(where+1);
        }
        setvalue(obj, where);
        activatecontrol(obj);
}
 
/*
 *  Perform some brush manipulation to handle background colours
 *  in native checkboxes and radio buttons.
 */
#if USE_NATIVE_TOGGLES
  #ifdef WM_CTLCOLOR
static void handle_colour(HDC dc, object obj)
{
	rgb fg, bg;
	COLORREF wincolour;
 
	if (obj->drawstate)
		fg = obj->drawstate->hue;
	else
		fg = obj->fg;
	wincolour = RGB((fg&Red)>>16,(fg&Green)>>8,(fg&Blue));
	SetTextColor(dc, wincolour);
 
	bg = obj->bg;
	wincolour = RGB((bg&Red)>>16,(bg&Green)>>8,(bg&Blue));
	SetBkColor(dc, wincolour);
 
	fix_brush(dc, obj, obj->bgbrush);
}
   #endif
#endif
 
static char dfilename[MAX_PATH + 1];
static void handle_drop(object obj, HANDLE dropstruct)
{
    if (obj->call && obj->call->drop) {
	int len = DragQueryFile(dropstruct, 0, NULL, 0);
	if (len > MAX_PATH) {
	    DragFinish(dropstruct);
	    return;
	}
	DragQueryFile(dropstruct, 0, dfilename, MAX_PATH);
	DragFinish(dropstruct);
	obj->call->drop(obj, dfilename);
    }
}
 
/*
 *  Shared window procedure code. The pass variable is initially zero.
 *  It can be set to non-zero in this procedure if we wish to pass
 *  the event to the default Windows winprocs.
 */
static long handle_message(HWND hwnd, UINT message,
			WPARAM wParam, LONG lParam, int *pass)
{
	object obj;
 
	/* Find the library object associated with the hwnd. */
	obj = find_by_handle(hwnd);
 
	if (! obj) { /* Not a library object ... */
		*pass = 1; /* ... so pass the event. */
		return 0;
	}
 
	frontwindow = obj; /* Needed for auto-mousedowns. */
 
	/* Handle mouse messages. */
	if ((message >= WM_MOUSEMOVE) && (message <= WM_MBUTTONDBLCLK))
	{
		handle_mouse(obj, hwnd, message, LOWORD(wParam),
				LOWORD(lParam), HIWORD(lParam));
		return 0;
	}
 
	/* Handle other messages. */
	switch (message)
	{
	case WM_KEYDOWN: /* record state of shift and control keys */
		handle_keydown(LOWORD(wParam));
		handle_virtual_keydown(obj, LOWORD(wParam));
		break;
 
	case WM_KEYUP: /* record state of shift and control keys */
		handle_keyup(LOWORD(wParam));
		break;
 
	case WM_CHAR:
		handle_char(obj, LOWORD(wParam));
		return 0;
 
	case WM_SETFOCUS:
		handle_focus(obj, 1);
		break;
 
	case WM_KILLFOCUS:
		handle_focus(obj, 0);
		break;
 
	case WM_PAINT:
		handle_redraw(obj, hwnd);
		return 0;
 
	case WM_INITMENUPOPUP:
		if (HIWORD(lParam)) /* true if system menu */
			return 0; /* else fall through */
	case WM_INITMENU:
		adjust_menu(wParam);
		break;
 
	case WM_MOVE:
		obj->rect.x = LOWORD(lParam);
		obj->rect.y = HIWORD(lParam);
		break;
 
	case WM_SIZE:
		obj->rect.width = LOWORD(lParam);
		obj->rect.height = HIWORD(lParam);
		handle_resize(obj);
		break;
 
	case WM_ACTIVATE:
		/* Keep track of which window is in front. */
		if (LOWORD(wParam) != WA_INACTIVE)
			move_to_front(obj);
		break;
 
	case WM_QUERYENDSESSION:
		handle_close(obj);
		return 1L; /* ensure Windows can terminate */
 
	case WM_CLOSE:
		handle_close(obj);
		return 0;
 
	case WM_DESTROY:
		handle_destroy(obj);
		break;
 
	/*case WM_SYSCOMMAND:*/
	case WM_COMMAND:
		if (LOWORD(wParam) >= MinDocID)
			break; /* MDI Client window will handle it */
		else if (LOWORD(wParam) >= MinChildID) {
		#ifdef WIN32
			handle_control((HWND) lParam, HIWORD(wParam));
		#else
			handle_control((HWND) LOWORD(lParam), HIWORD(lParam));
		#endif /* WIN32 */
		}
		else if ((LOWORD(wParam) >= MinMenuID) && menus_active)
			handle_menu_id(LOWORD(wParam));
		break;
 
	case WM_VSCROLL:
	case WM_HSCROLL:
		#ifdef WIN32
		if ( lParam != 0) { /* scrollbar object */
			hwnd = (HWND) lParam;
		#else
		if (HIWORD(lParam) != 0) { /* scrollbar object */
			hwnd = (HWND) HIWORD(lParam);
		#endif /* WIN32 */
			obj = find_by_handle(hwnd);
			if (! obj)
				return 0;
		}
		handle_scroll(obj, hwnd, message, wParam, lParam);
		return 0;
 
#if USE_NATIVE_TOGGLES
  #ifdef WM_CTLCOLOR
	case WM_CTLCOLOR:
		#ifdef WIN32
		hwnd = (HWND) lParam;
		#else
		hwnd = (HWND) LOWORD(lParam);
		#endif  /* WIN32 */
 
		obj = find_by_handle(hwnd);
		if (! obj)
			break;
		if ((obj->kind != CheckboxObject) && (obj->kind != RadioObject))
			break;
		handle_colour((HDC) wParam, obj);
		return (LRESULT) obj->bgbrush;
  #endif
#endif
        case WM_DROPFILES:
		handle_drop(obj, (HANDLE) wParam);
	}
 
	/* If we got this far the event must be passed along
	 * to the default Windows event handling procedures. */
	*pass = 1;
	return 0;
}
 
/*
 *  Window procedures call a generic window handling routine.
 *  We need three window procedures since the different calls
 *  tell us which default window procedure to pass the messages
 *  to if we don't wish to handle a message.
 *  If we were to use only one window procedure, we would have to
 *  have a way of determining which is the default window proc
 *  for a window from just knowing the hwnd (which may or may not
 *  belong to us).
 */
long FAR PASCAL _export
app_win_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	long result;
	int pass = 0;
 
	result = handle_message(hwnd, message, wParam, lParam, &pass);
	if (pass)
		result = DefWindowProc(hwnd, message, wParam, lParam);
	return result;
}
 
long FAR PASCAL _export
app_doc_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	long result;
	int pass = 0;
	object obj;
        if ((message==WM_MDIACTIVATE) && ((HWND)lParam==hwnd)) {
            if (MDIToolbar) hide(MDIToolbar);
            obj = find_by_handle(hwnd);
            MDIToolbar = (obj) ? obj->toolbar : NULL;
            handle_mdiframesize();
            if (obj && obj->menubar) {
                menu mdi = (obj->menubar)->menubar;
	        SendMessage(hwndClient, WM_MDISETMENU,
                        (WPARAM)obj->menubar->handle,
			(LPARAM)(mdi?(mdi->handle):0));
                DrawMenuBar(hwndFrame);
            }
            updatestatus(obj->status);
            RedrawWindow(hwndFrame,NULL,NULL,
                         RDW_UPDATENOW|RDW_ALLCHILDREN);
            SetFocus(hwnd);
            return 1;
	}
	result = handle_message(hwnd, message, wParam, lParam, &pass);
	if (pass)
		result = DefMDIChildProc(hwnd, message, wParam, lParam);
	return result;
}
 
long FAR PASCAL _export
app_work_proc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	long result;
	int pass = 0;
	result = handle_message(hwnd, message, wParam, lParam, &pass);
	if (pass)
		result = DefFrameProc(hwnd, hwndClient, message, wParam, lParam);
	return result;
}
 
/*
 *  To handle controls correctly, we replace each control's event
 *  handling procedure with our own when we create it. We handle
 *  certain events ourselves, and pass the rest to the default
 *  routines.
 *  Things we do here include: allowing the TAB key to change
 *  input focus to the next control; for one-line text fields
 *  pressing return causes the event to be sent to the parent window.
 */
 
/* Send a char to an object, or its parent if it has no handler. */
static void send_char(object obj, int ch)
{
	while (obj) {
	    if ((obj->call) && (obj->call->keydown))
		break;
	    obj = obj->parent;
	}
	if (! obj)
		return;
	if (ch == '\r')
		ch = '\n';
	drawto(obj);
	obj->call->keydown(obj, ch);
        keystate = 0;
}
 
long FAR PASCAL _export
app_control_procedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int prevent_activation = 0;
	int key;
	long result;
	object obj, next;
 
	/* Find the library object associated with the hwnd. */
	obj = find_by_handle(hwnd);
	key = LOWORD(wParam);
 
	if (! obj) /* Not a library object ... */
		return 0; /* ... so do nothing. */
	if (! obj->winproc)
		return 0; /* Nowhere to send events! */
 
	next = find_valid_sibling(obj->next);
 
	if (message == WM_KEYDOWN)
		handle_keydown(key);
	else if (message == WM_KEYUP)
		handle_keyup(key);
 
	switch (message)
	{
	  case WM_KEYDOWN:
	    if (obj->kind == TextboxObject) {
		if ((key == VK_TAB) && (keystate & CtrlKey)) {
			SetFocus(next->handle);
			return 0;
		  }
	    	break;
	    }
	    if (key == VK_TAB) {
		SetFocus(next->handle);
		return 0;
	    }
	    else if ((key == VK_RETURN) || (key == VK_ESCAPE)) {
		send_char(obj, key);
		return 0;
	    }
	    break;
 
	  case WM_CHAR:
	    switch (obj->kind) {
		case TextboxObject:
			break;
		case LabelObject:
		case ButtonObject:   case CheckboxObject:
		case RadioObject:    case ScrollbarObject:
		case ListboxObject:  case MultilistObject:
		case DroplistObject: case DropfieldObject:
			if (key != ' ') {
				send_char(obj, key);
				return 0;
			}
		case FieldObject:
			if (key == '\t')
				return 0;
			if ((key == '\n') || (key == ESC))
				return 0;
		break;
	    }
	    break;
 
	  case WM_SETFOCUS:
	    if (obj->kind == RadioObject) {
		/* Temporarily disable the control manually.
		 * We do this to work around the way Windows
		 * sends WM_COMMAND messages to radio buttons
		 * when we use TAB to set focus to them. */
#if USE_NATIVE_TOGGLES
		if (isenabled(obj)) {
			obj->state &= ~Enabled;
			prevent_activation = 1;
		}
#endif
	    }
	    else if (obj->kind == FieldObject) {
		#ifdef WIN32
		sendmessage(hwnd, EM_SETSEL, 32767, 32767);
		#else
		sendmessage(hwnd, EM_SETSEL, 0, MAKELONG(32767,32767));
		#endif /* WIN32 */
	    }
	    break;
	}
 
	result = CallWindowProc((obj->winproc), hwnd, message, wParam, lParam);
 
	/* Re-activate the control if necessary. */
	if (prevent_activation)
		obj->state |= Enabled;
	return result;
}
 
/*
 *  Timer functions use a timer procedure not associated with a window.
 *  We use this one procedure to handle both timer events and mouse-down
 *  timer events. The mouse-down timer happens when the user has held
 *  a mouse button down for longer than mouse_msec milliseconds, and
 *  it causes the last mouse event to repeat.
 */
UINT FAR PASCAL _export
app_timer_procedure(HWND hwnd, UINT message, UINT tid, DWORD time)
{
	object obj;
	UINT id = LOWORD(tid);
 
	if ((id == 0) || (message != WM_TIMER))
		return 0;
 
	if (id == mouse_timer_id) {
		obj = frontwindow;
		if ((buttons == 0) || (! obj) || (! obj->call)
			|| (! obj->call->mouserepeat))
				setmousetimer(0);
		else
			obj->call->mouserepeat(obj, buttons, xy);
	}
	else if (id == timer_id) {
		if (do_timer)
			do_timer(timer_data);
	}
 
	return 0;
}
 
/*
 *  Set the timer function.
 */
void settimerfn(timerfn timeout, void *data)
{
	do_timer = timeout;
	timer_data = data;
}
 
/*
 * Start the timer with a period of msec milliseconds.
 */
int settimer(unsigned msec)
{
	if (timer_id != 0) {
		KillTimer(0, timer_id);
		timer_id = 0;
	}
	if (msec == 0)
		timer_id = 0;
	else {
		timer_id = SetTimer(0, 0, (UINT) msec, app_timer_proc);
		if (timer_id == 0)
			return 0;
	}
	return 1;
}
 
/*
 * Start the mouse-down timer with a period of msec milliseconds.
 *
 * Notes: setmousetimer() starts the mouse-down auto-repeat timer.
 *  The timer will not do anything unless the user holds down a
 *  mouse button for longer than msec milliseconds, in which case
 *  it will call the mouserepeat function associated with which ever
 *  window is currently active.
 *  Also, an interval of zero should stop the timer without
 *  destroying the previous interval recorded in mouse_msec.
 */
int setmousetimer(unsigned msec)
{
	if (mouse_timer_id != 0) {
		KillTimer(0, mouse_timer_id);
		mouse_timer_id = 0;
	}
	if (msec == 0) {
		mouse_timer_id = 0;
		return 1;
	}
	else {
		mouse_timer_id = SetTimer(0, 0, (UINT) msec, app_timer_proc);
		if (mouse_timer_id == 0)
			return 0;
	}
	mouse_msec = msec;
	return 1;
}
 
/*
 *  Delay execution for a given number of milliseconds.
 *  This is a blocking function which should be used sparingly.
 */
void delay(unsigned msec)
{
	unsigned long now;
	unsigned long stop;
 
	stop = msec;
	now = GetTickCount();
	stop += now;
	while(now < stop)
		now = GetTickCount();
}
 
/*
 *  Report current time in milliseconds since initialisation of
 *  the graphics interface. Not reliable for timing events.
 */
long currenttime(void)
{
	return GetTickCount();
}
 
/*
 *  Intercept menu keys, since we don't always have accelerator tables.
 *  Return 1 if doing something which should not go to the winproc, else 0.
 */
static int TranslateMenuKeys(MSG *msg)
{
	int key = LOWORD(msg->wParam);
 
	/* Translate F10 from syskey to normal keydown message. */
	if ((key == VK_F10) && (msg->message == WM_SYSKEYDOWN))
		msg->message = WM_KEYDOWN;
 
	/* Check for menu control keys. */
/* disabled : Alt-Gr bug*/
        return 0;
	if ((keystate & CtrlKey) && (msg->message == WM_KEYDOWN))
	{
		/* ctrl-letter or ctrl-number is a menu key */
		if (((key >= 'A') && (key <= 'Z')) ||
			((key >= '0') && (key <= '9')))
		{
			if (menus_active)
				handle_menu_key(key);
			return 1;
		}
	}
 
	return 0; /* 0 = pass to TranslateMessage and DispatchMessage */
}
 
/*
 *  Return zero if there are no messages, non-zero otherwise.
 */
int peekevent(void)
{
	return PeekMessage(&msg, 0, 0, 0, PM_NOREMOVE);
}
 
/*
 *  Handle one event.
 */
int doevent(void)
{
	int result = PeekMessage(&msg, 0, 0, 0, PM_REMOVE);
 
	if (result)
	{
	  /*		del_all_contexts();*/
		if (TranslateMenuKeys(&msg))
			return result;
		if ((hwndClient) &&
			TranslateMDISysAccel(hwndClient, &msg))
			return result;
		if ((hwndFrame) && (hAccel) &&
			TranslateAccelerator(hwndFrame, hAccel, &msg))
			return result;
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	deletion_traversal();
	if ((active_windows <= 0) || (msg.message == WM_QUIT))
		return 0;
	else
		return 1;
}
 
/*
 *  Handle events until the program has finished receiving events,
 *  or until there are no windows open to receive events.
 */
void gamainloop(void)
{
	while (doevent())
		continue;
}
 
/*
 *  Finish all pending graphics requests.
 */
void drawall(void)
{
	/* Do nothing here. */
}
 
/*
 *  Initialise the timer and make some instance 'thunks' for
 *  the event callbacks.
 */
PROTECTED
void init_events(void)
{
	app_timer_proc = (TIMERPROC) MakeProcInstance((FARPROC) app_timer_procedure,
				this_instance);
	setmousetimer(100); /* start 1/10 second mouse-down auto-repeat */
 
	app_control_proc = (WNDPROC) MakeProcInstance((FARPROC) app_control_procedure,
				this_instance);
}
 
/*
 *  Stop all timers and release the memory requirements of
 *  the proc instance 'thunks'.
 */
PROTECTED
void finish_events(void)
{
	settimer(0);
	setmousetimer(0);
}

Rev 24283	Rev 24322
1	`/*`	1	`/*`
2	`* GraphApp - Cross-Platform Graphics Programming Library.`	2	`* GraphApp - Cross-Platform Graphics Programming Library.`
3	`*`	3	`*`
4	`* File: events.c -- winprocs and timers are contained here.`	4	`* File: events.c -- winprocs and timers are contained here.`
5	`* Platform: Windows Version: 2.35 Date: 1998/04/04`	5	`* Platform: Windows Version: 2.35 Date: 1998/04/04`
6	`*`	6	`*`
7	`* Version: 1.00 Changes: Original version by Lachlan Patrick.`	7	`* Version: 1.00 Changes: Original version by Lachlan Patrick.`
8	`* Version: 2.00 Changes: New class system implemented.`	8	`* Version: 2.00 Changes: New class system implemented.`
9	`* Version: 2.20 Changes: Non-native buttons supported.`	9	`* Version: 2.20 Changes: Non-native buttons supported.`
10	`* Version: 2.22 Changes: 32-bit fix by Wim Rijnders.`	10	`* Version: 2.22 Changes: 32-bit fix by Wim Rijnders.`
11	`* Version: 2.35 Changes: New delayed deletion technique.`	11	`* Version: 2.35 Changes: New delayed deletion technique.`
12	`*/`	12	`*/`
13		13
14	`/* Copyright (C) 1993-1998 Lachlan Patrick`	14	`/* Copyright (C) 1993-1998 Lachlan Patrick`
15		15
16	`This file is part of GraphApp, a cross-platform C graphics library.`	16	`This file is part of GraphApp, a cross-platform C graphics library.`
17		17
18	`GraphApp is free software; you can redistribute it and/or modify it`	18	`GraphApp is free software; you can redistribute it and/or modify it`
19	`under the terms of the GNU Library General Public License.`	19	`under the terms of the GNU Library General Public License.`
20	`GraphApp is distributed in the hope that it will be useful, but`	20	`GraphApp is distributed in the hope that it will be useful, but`
21	`WITHOUT ANY WARRANTY.`	21	`WITHOUT ANY WARRANTY.`
22		22
23	`See the file COPYLIB.TXT for details.`	23	`See the file COPYLIB.TXT for details.`
24	`*/`	24	`*/`
25		25
26	`#include "internal.h"`	26	`#include "internal.h"`
27		27
28	`/*`	28	`/*`
29	`* Library variables.`	29	`* Library variables.`
30	`*/`	30	`*/`
31	`static timerfn do_timer = NULL;`	31	`static timerfn do_timer = NULL;`
32	`static void *timer_data = NULL;`	32	`static void *timer_data = NULL;`
33		33
34	`static MSG msg;`	34	`static MSG msg;`
35	`PROTECTED int keystate = 0; /* state of shift, ctrl and alt keys */`	35	`PROTECTED int keystate = 0; /* state of shift, ctrl and alt keys */`
36		36
37	`/* a user-timer and a mouse-down timer function can be started */`	37	`/* a user-timer and a mouse-down timer function can be started */`
38		38
39	`static UINT timer_id = 0;`	39	`static UINT timer_id = 0;`
40	`static UINT mouse_timer_id = 0;`	40	`static UINT mouse_timer_id = 0;`
41		41
42	`/* buttons and xy are used to record the state of the mouse */`	42	`/* buttons and xy are used to record the state of the mouse */`
43		43
44	`static int buttons = 0;`	44	`static int buttons = 0;`
45	`static point xy;`	45	`static point xy;`
46		46
47	`static long mouse_msec = 0;`	47	`static long mouse_msec = 0;`
48		48
49	`TIMERPROC app_timer_proc;`	49	`TIMERPROC app_timer_proc;`
50	`WNDPROC app_control_proc;`	50	`WNDPROC app_control_proc;`
51		51
52	`static object frontwindow = NULL; /* the window receiving events */`	52	`static object frontwindow = NULL; /* the window receiving events */`
53		53
54	`/*`	54	`/*`
55	`* Call the relevent mouse handler function.`	55	`* Call the relevent mouse handler function.`
56	`*/`	56	`*/`
57	`static void handle_mouse(object obj, HWND hwnd, UINT message,`	57	`static void handle_mouse(object obj, HWND hwnd, UINT message,`
58	`int param, int x, int y)`	58	`int param, int x, int y)`
59	`{`	59	`{`
60	`menu m;`	60	`menu m;`
61	`POINT wp;`	61	`POINT wp;`
62	`HWND hw;`	62	`HWND hw;`
63	`int dble = 1;`	63	`int dble = 1;`
64		64
65	`xy.x = x;`	65	`xy.x = x;`
66	`xy.y = y;`	66	`xy.y = y;`
67	`buttons = 0;`	67	`buttons = 0;`
68	`if (!obj) return;`	68	`if (!obj) return;`
69	`if (param & MK_LBUTTON)`	69	`if (param & MK_LBUTTON)`
70	`buttons \|= LeftButton;`	70	`buttons \|= LeftButton;`
71	`if (param & MK_MBUTTON)`	71	`if (param & MK_MBUTTON)`
72	`buttons \|= MiddleButton;`	72	`buttons \|= MiddleButton;`
73	`if (param & MK_RBUTTON)`	73	`if (param & MK_RBUTTON)`
74	`buttons \|= RightButton;`	74	`buttons \|= RightButton;`
75		75
76	`/* dispatch the mouse event to the relevent handler */`	76	`/* dispatch the mouse event to the relevent handler */`
77	`if (obj && obj->drawstate && obj->drawstate->crsr)`	77	`if (obj && obj->drawstate && obj->drawstate->crsr)`
78	`SetCursor((HCURSOR)obj->drawstate->crsr->handle);`	78	`SetCursor((HCURSOR)obj->drawstate->crsr->handle);`
79		79
80	`switch (message)`	80	`switch (message)`
81	`{`	81	`{`
82	`case WM_MOUSEMOVE:`	82	`case WM_MOUSEMOVE:`
83	`if (obj->call) {`	83	`if (obj->call) {`
84	`if (buttons) {`	84	`if (buttons) {`
85	`if (obj->call->mousedrag)`	85	`if (obj->call->mousedrag)`
86	`obj->call->mousedrag(obj, buttons, xy);`	86	`obj->call->mousedrag(obj, buttons, xy);`
87	`}`	87	`}`
88	`else if (obj->call->mousemove)`	88	`else if (obj->call->mousemove)`
89	`obj->call->mousemove(obj, buttons, xy);`	89	`obj->call->mousemove(obj, buttons, xy);`
90	`}`	90	`}`
91	`break;`	91	`break;`
92	`case WM_LBUTTONDOWN:`	92	`case WM_LBUTTONDOWN:`
93	`case WM_RBUTTONDOWN:`	93	`case WM_RBUTTONDOWN:`
94	`case WM_MBUTTONDOWN:`	94	`case WM_MBUTTONDOWN:`
95	`dble = 0;`	95	`dble = 0;`
96	`setmousetimer(mouse_msec); /* restart timer */`	96	`setmousetimer(mouse_msec); /* restart timer */`
97	`/* fall through to next case */`	97	`/* fall through to next case */`
98	`case WM_LBUTTONDBLCLK:`	98	`case WM_LBUTTONDBLCLK:`
99	`case WM_RBUTTONDBLCLK:`	99	`case WM_RBUTTONDBLCLK:`
100	`case WM_MBUTTONDBLCLK:`	100	`case WM_MBUTTONDBLCLK:`
101	`if (dble) buttons \|= DblClick;`	101	`if (dble) buttons \|= DblClick;`
102	`if ((obj->flags & ChildWindow) && (obj->kind != LabelObject))`	102	`if ((obj->flags & ChildWindow) && (obj->kind != LabelObject))`
103	`SetFocus(hwnd);`	103	`SetFocus(hwnd);`
104	`if (obj->flags & TrackMouse)`	104	`if (obj->flags & TrackMouse)`
105	`SetCapture(hwnd);`	105	`SetCapture(hwnd);`
106	`if (buttons == RightButton) {`	106	`if (buttons == RightButton) {`
107	`m = obj->popup; hw = hwnd;`	107	`m = obj->popup; hw = hwnd;`
108	`if (!m) {`	108	`if (!m) {`
109	`m = obj->parent->popup;`	109	`m = obj->parent->popup;`
110	`hw = (HWND) obj->parent->handle;`	110	`hw = (HWND) obj->parent->handle;`
111	`}`	111	`}`
112	`if (m) {`	112	`if (m) {`
113	`wp.x = x; wp.y = y;`	113	`wp.x = x; wp.y = y;`
114	`ClientToScreen(hw, (LPPOINT) &wp);`	114	`ClientToScreen(hw, (LPPOINT) &wp);`
115	`if (m->action) m->action(m);`	115	`if (m->action) m->action(m);`
116	`TrackPopupMenu(m->handle,`	116	`TrackPopupMenu(m->handle,`
117	`TPM_LEFTALIGN\|`	117	`TPM_LEFTALIGN\|`
118	`TPM_LEFTBUTTON\|TPM_RIGHTBUTTON,`	118	`TPM_LEFTBUTTON\|TPM_RIGHTBUTTON,`
119	`wp.x,wp.y,`	119	`wp.x,wp.y,`
120	`0,`	120	`0,`
121	`obj->handle,`	121	`obj->handle,`
122	`NULL);`	122	`NULL);`
123	`break;`	123	`break;`
124	`}`	124	`}`
125	`}`	125	`}`
126	`if (obj->call && obj->call->mousedown)`	126	`if (obj->call && obj->call->mousedown)`
127	`obj->call->mousedown(obj, buttons, xy);`	127	`obj->call->mousedown(obj, buttons, xy);`
128	`break;`	128	`break;`
129	`case WM_LBUTTONUP:`	129	`case WM_LBUTTONUP:`
130	`case WM_RBUTTONUP:`	130	`case WM_RBUTTONUP:`
131	`case WM_MBUTTONUP:`	131	`case WM_MBUTTONUP:`
132	`if ((obj->flags & TrackMouse) && (buttons == 0))`	132	`if ((obj->flags & TrackMouse) && (buttons == 0))`
133	`ReleaseCapture();`	133	`ReleaseCapture();`
134	`if (obj->call && obj->call->mouseup)`	134	`if (obj->call && obj->call->mouseup)`
135	`obj->call->mouseup(obj, buttons, xy);`	135	`obj->call->mouseup(obj, buttons, xy);`
136	`break;`	136	`break;`
137	`}`	137	`}`
138	`}`	138	`}`
139		139
140	`/*`	140	`/*`
141	`* Some WM_KEYDOWN VK_* messages call the keyaction associated`	141	`* Some WM_KEYDOWN VK_* messages call the keyaction associated`
142	`* with a window.`	142	`* with a window.`
143	`*/`	143	`*/`
144	`static void handle_virtual_keydown(object obj, int param)`	144	`static void handle_virtual_keydown(object obj, int param)`
145	`{`	145	`{`
146	`if ((! obj->call) \|\| (! obj->call->keyaction))`	146	`if ((! obj->call) \|\| (! obj->call->keyaction))`
147	`return;`	147	`return;`
148		148
149	`/* translate arrow key combinations into Unicode arrow symbols */`	149	`/* translate arrow key combinations into Unicode arrow symbols */`
150	`if ((param >= VK_LEFT) && (param <= VK_DOWN)) {`	150	`if ((param >= VK_LEFT) && (param <= VK_DOWN)) {`
151	`param += (LEFT - VK_LEFT);`	151	`param += (LEFT - VK_LEFT);`
152	`}`	152	`}`
153		153
154	`/* translate functions keys into Unicode circled numbers */`	154	`/* translate functions keys into Unicode circled numbers */`
155	`else if ((param >= VK_F1) && (param <= VK_F10)) {`	155	`else if ((param >= VK_F1) && (param <= VK_F10)) {`
156	`param += (F1 - VK_F1);`	156	`param += (F1 - VK_F1);`
157	`}`	157	`}`
158		158
159	`/* translate other keyboard keys into Unicode 'equivalents' */`	159	`/* translate other keyboard keys into Unicode 'equivalents' */`
160	`else switch (param) {`	160	`else switch (param) {`
161	`case VK_PRIOR: param = PGUP; break;`	161	`case VK_PRIOR: param = PGUP; break;`
162	`case VK_NEXT: param = PGDN; break;`	162	`case VK_NEXT: param = PGDN; break;`
163	`case VK_END: param = END; break;`	163	`case VK_END: param = END; break;`
164	`case VK_HOME: param = HOME; break;`	164	`case VK_HOME: param = HOME; break;`
165	`case VK_INSERT: param = INS; break;`	165	`case VK_INSERT: param = INS; break;`
166	`case VK_DELETE: param = DEL; break;`	166	`case VK_DELETE: param = DEL; break;`
167	`default: return; /* do nothing */`	167	`default: return; /* do nothing */`
168	`}`	168	`}`
169		169
170	`drawto(obj);`	170	`drawto(obj);`
171	`obj->call->keyaction(obj, param);`	171	`obj->call->keyaction(obj, param);`
172	`}`	172	`}`
173		173
174	`static void handle_keydown(int param)`	174	`static void handle_keydown(int param)`
175	`{`	175	`{`
176	`if (param == VK_SHIFT)`	176	`if (param == VK_SHIFT)`
177	`keystate \|= ShiftKey;`	177	`keystate \|= ShiftKey;`
178	`else if (param == VK_CONTROL)`	178	`else if (param == VK_CONTROL)`
179	`keystate \|= CtrlKey;`	179	`keystate \|= CtrlKey;`
180	`else if (param == VK_MENU)`	180	`else if (param == VK_MENU)`
181	`keystate \|= AltKey;`	181	`keystate \|= AltKey;`
182	`}`	182	`}`
183		183
184	`static void handle_keyup(int param)`	184	`static void handle_keyup(int param)`
185	`{`	185	`{`
186	`if (param == VK_SHIFT)`	186	`if (param == VK_SHIFT)`
187	`keystate &= ~ShiftKey;`	187	`keystate &= ~ShiftKey;`
188	`else if (param == VK_CONTROL)`	188	`else if (param == VK_CONTROL)`
189	`keystate &= ~CtrlKey;`	189	`keystate &= ~CtrlKey;`
190	`else if (param == VK_MENU)`	190	`else if (param == VK_MENU)`
191	`keystate &= ~AltKey;`	191	`keystate &= ~AltKey;`
192	`}`	192	`}`
193		193
194	`/*`	194	`/*`
195	`* Handle char messages.`	195	`* Handle char messages.`
196	`*/`	196	`*/`
197	`static void handle_char(object obj, int ch)`	197	`static void handle_char(object obj, int ch)`
198	`{`	198	`{`
199	`if (obj->call && obj->call->keydown) {`	199	`if (obj->call && obj->call->keydown) {`
200	`if (ch == '\r') /* carriage return becomes newline */`	200	`if (ch == '\r') /* carriage return becomes newline */`
201	`ch = '\n';`	201	`ch = '\n';`
202	`drawto(obj);`	202	`drawto(obj);`
203	`obj->call->keydown(obj, ch);`	203	`obj->call->keydown(obj, ch);`
204	`}`	204	`}`
205	`}`	205	`}`
206		206
207	`static void handle_mdiframesize() {`	207	`static void handle_mdiframesize() {`
208	`HWND tool=NULL ,status=NULL;`	208	`HWND tool=NULL ,status=NULL;`
209	`RECT rFrame,rToolbar;`	209	`RECT rFrame,rToolbar;`
210	`int fw, fh, th=0, sh=0;`	210	`int fw, fh, th=0, sh=0;`
211	`GetClientRect(hwndFrame,&rFrame);`	211	`GetClientRect(hwndFrame,&rFrame);`
212	`fw = rFrame.right-rFrame.left;`	212	`fw = rFrame.right-rFrame.left;`
213	`fh = rFrame.bottom-rFrame.top;`	213	`fh = rFrame.bottom-rFrame.top;`
214	`if (MDIToolbar) {`	214	`if (MDIToolbar) {`
215	`tool = (HWND)MDIToolbar->handle;`	215	`tool = (HWND)MDIToolbar->handle;`
216	`GetWindowRect(tool,&rToolbar);`	216	`GetWindowRect(tool,&rToolbar);`
217	`th = rToolbar.bottom-rToolbar.top;`	217	`th = rToolbar.bottom-rToolbar.top;`
218	`}`	218	`}`
219	`if (MDIStatus) {`	219	`if (MDIStatus) {`
220	`status = (HWND)MDIStatus;`	220	`status = (HWND)MDIStatus;`
221	`GetWindowRect(status,&rToolbar);`	221	`GetWindowRect(status,&rToolbar);`
222	`sh = rToolbar.bottom-rToolbar.top;`	222	`sh = rToolbar.bottom-rToolbar.top;`
223	`}`	223	`}`
224	`MoveWindow(hwndClient,0,th+1,fw,fh-sh-th-1,TRUE);`	224	`MoveWindow(hwndClient,0,th+1,fw,fh-sh-th-1,TRUE);`
225	`if (tool) {`	225	`if (tool) {`
226	`MoveWindow(tool,1,0,fw-2,th,TRUE);`	226	`MoveWindow(tool,1,0,fw-2,th,TRUE);`
227	`show(MDIToolbar);`	227	`show(MDIToolbar);`
228	`}`	228	`}`
229	`if (status) {`	229	`if (status) {`
230	`MoveWindow(status,1,fh-sh,fw-2,sh,TRUE);`	230	`MoveWindow(status,1,fh-sh,fw-2,sh,TRUE);`
231	`}`	231	`}`
232	`SetFocus((HWND)SendMessage(hwndClient,`	232	`SetFocus((HWND)SendMessage(hwndClient,`
233	`WM_MDIGETACTIVE,(WPARAM)0,(LPARAM) 0));`	233	`WM_MDIGETACTIVE,(WPARAM)0,(LPARAM) 0));`
234	`}`	234	`}`
235		235
236	`/*`	236	`/*`
237	`* The window is being resized for some reason.`	237	`* The window is being resized for some reason.`
238	`*/`	238	`*/`
239	`static void handle_resize(object obj)`	239	`static void handle_resize(object obj)`
240	`{`	240	`{`
241	`if (obj->call && obj->call->resize) {`	241	`if (obj->call && obj->call->resize) {`
242	`drawto(obj);`	242	`drawto(obj);`
243	`obj->call->resize(obj,`	243	`obj->call->resize(obj,`
244	`rect(0,0,obj->rect.width,obj->rect.height));`	244	`rect(0,0,obj->rect.width,obj->rect.height));`
245	`}`	245	`}`
-		246	`deletion_traversal(); /* We may be called again before`
-		247	`returning to doevent */`
246	`}`	248	`}`
247		249
248	`/*`	250	`/*`
249	`* The window is being redrawn for some reason.`	251	`* The window is being redrawn for some reason.`
250	`*/`	252	`*/`
251	`static void handle_redraw(object obj, HWND hwnd)`	253	`static void handle_redraw(object obj, HWND hwnd)`
252	`{`	254	`{`
253	`PAINTSTRUCT ps;`	255	`PAINTSTRUCT ps;`
254	`if (obj==MDIFrame)`	256	`if (obj==MDIFrame)`
255	`handle_mdiframesize();`	257	`handle_mdiframesize();`
256	`del_context(obj);`	258	`del_context(obj);`
257	`add_context(obj, BeginPaint(hwnd, &ps), NULL);`	259	`add_context(obj, BeginPaint(hwnd, &ps), NULL);`
258	`if (ps.fErase)`	260	`if (ps.fErase)`
259	`clear(obj);`	261	`clear(obj);`
260	`draw(obj);`	262	`draw(obj);`
261	`EndPaint(hwnd, &ps);`	263	`EndPaint(hwnd, &ps);`
262	`remove_context(obj);`	264	`remove_context(obj);`
263	`dc = 0;`	265	`dc = 0;`
264	`}`	266	`}`
265		267
266	`/*`	268	`/*`
267	`* Hide an application window, or call close() function if possible.`	269	`* Hide an application window, or call close() function if possible.`
268	`*/`	270	`*/`
269	`static void handle_close(object obj)`	271	`static void handle_close(object obj)`
270	`{`	272	`{`
271	`if (obj->call && obj->call->close) {`	273	`if (obj->call && obj->call->close) {`
272	`drawto(obj);`	274	`drawto(obj);`
273	`obj->call->close(obj);`	275	`obj->call->close(obj);`
274	`} else {`	276	`} else {`
275	`hide(obj);`	277	`hide(obj);`
276	`}`	278	`}`
277	`}`	279	`}`
278		280
279	`static void handle_destroy(object obj)`	281	`static void handle_destroy(object obj)`
280	`{`	282	`{`
281	`/*`	283	`/*`
282	`drawto(obj);`	284	`drawto(obj);`
283	`del_object(obj);`	285	`del_object(obj);`
284	`*/`	286	`*/`
285	`}`	287	`}`
286		288
287	`static void handle_focus(object obj, int gained_focus)`	289	`static void handle_focus(object obj, int gained_focus)`
288	`{`	290	`{`
289	`if (gained_focus)`	291	`if (gained_focus)`
290	`obj->state \|= Focus;`	292	`obj->state \|= Focus;`
291	`else`	293	`else`
292	`obj->state &= ~Focus;`	294	`obj->state &= ~Focus;`
293	`if ((! USE_NATIVE_BUTTONS) && (obj->kind == ButtonObject))`	295	`if ((! USE_NATIVE_BUTTONS) && (obj->kind == ButtonObject))`
294	`InvalidateRect(obj->handle, NULL, 0);`	296	`InvalidateRect(obj->handle, NULL, 0);`
295	`}`	297	`}`
296		298
297	`/*`	299	`/*`
298	`* Handle scrollbars. Designed to also work with normal window`	300	`* Handle scrollbars. Designed to also work with normal window`
299	`* scrollbars.`	301	`* scrollbars.`
300	`*/`	302	`*/`
301	`static void handle_scroll(object obj, HWND hwnd, UINT message,`	303	`static void handle_scroll(object obj, HWND hwnd, UINT message,`
302	`WPARAM wParam, LPARAM lParam)`	304	`WPARAM wParam, LPARAM lParam)`
303	`{`	305	`{`
304	`int size_shown = 10;`	306	`int size_shown = 10;`
305	`int max_value = 100;`	307	`int max_value = 100;`
306	`int where = 0;`	308	`int where = 0;`
307	`int prev = 0;`	309	`int prev = 0;`
308	`/* we need to look at the recorded values */`	310	`/* we need to look at the recorded values */`
309	`max_value = obj->max;`	311	`max_value = obj->max;`
310	`size_shown = obj->size;`	312	`size_shown = obj->size;`
311	`if (obj->kind != WindowObject) {`	313	`if (obj->kind != WindowObject) {`
312	`prev = where = GetScrollPos(hwnd, SB_CTL);`	314	`prev = where = GetScrollPos(hwnd, SB_CTL);`
313	`}`	315	`}`
314	`else if (message == WM_VSCROLL) {`	316	`else if (message == WM_VSCROLL) {`
315	`prev = where = GetScrollPos(hwnd, SB_VERT);`	317	`prev = where = GetScrollPos(hwnd, SB_VERT);`
316	`} else if (message == WM_HSCROLL) {`	318	`} else if (message == WM_HSCROLL) {`
317	`prev = where = GetScrollPos(hwnd, SB_HORZ);`	319	`prev = where = GetScrollPos(hwnd, SB_HORZ);`
318	`max_value = obj->xmax;`	320	`max_value = obj->xmax;`
319	`size_shown = obj->xsize;`	321	`size_shown = obj->xsize;`
320	`}`	322	`}`
321		323
322	`/* next we look at wParam to see what happened */`	324	`/* next we look at wParam to see what happened */`
323	`switch(LOWORD(wParam))`	325	`switch(LOWORD(wParam))`
324	`{`	326	`{`
325	`case SB_PAGEDOWN: where += (size_shown-1);`	327	`case SB_PAGEDOWN: where += (size_shown-1);`
326	`/* fall through to next case */`	328	`/* fall through to next case */`
327	`case SB_LINEDOWN: where = min(max_value, where+1);`	329	`case SB_LINEDOWN: where = min(max_value, where+1);`
328	`break;`	330	`break;`
329	`case SB_PAGEUP: where -= (size_shown-1);`	331	`case SB_PAGEUP: where -= (size_shown-1);`
330	`/* fall through to next case */`	332	`/* fall through to next case */`
331	`case SB_LINEUP: where = max(0, where-1);`	333	`case SB_LINEUP: where = max(0, where-1);`
332	`break;`	334	`break;`
333	`case SB_TOP: where = 0;`	335	`case SB_TOP: where = 0;`
334	`break;`	336	`break;`
335	`case SB_BOTTOM: where = max_value;`	337	`case SB_BOTTOM: where = max_value;`
336	`break;`	338	`break;`
337	`case SB_THUMBPOSITION:`	339	`case SB_THUMBPOSITION:`
338	`case SB_THUMBTRACK:`	340	`case SB_THUMBTRACK:`
339	`#ifdef WIN32`	341	`#ifdef WIN32`
340	`where = HIWORD(wParam);`	342	`where = HIWORD(wParam);`
341	`#else`	343	`#else`
342	`where = LOWORD(lParam);`	344	`where = LOWORD(lParam);`
343	`#endif`	345	`#endif`
344	`break;`	346	`break;`
345	`default: break;`	347	`default: break;`
346	`}`	348	`}`
347	`/* check if something happened */`	349	`/* check if something happened */`
348	`if (prev == where)`	350	`if (prev == where)`
349	`return;`	351	`return;`
350	`/* now we reset the scrollbar's values */`	352	`/* now we reset the scrollbar's values */`
351	`if (obj->kind != WindowObject) {`	353	`if (obj->kind != WindowObject) {`
352	`SetScrollPos(hwnd, SB_CTL, where, 1);`	354	`SetScrollPos(hwnd, SB_CTL, where, 1);`
353	`}`	355	`}`
354	`else if (message == WM_VSCROLL) {`	356	`else if (message == WM_VSCROLL) {`
355	`SetScrollPos(hwnd, SB_VERT, where, 1);`	357	`SetScrollPos(hwnd, SB_VERT, where, 1);`
356	`}`	358	`}`
357	`else if (message == WM_HSCROLL) {`	359	`else if (message == WM_HSCROLL) {`
358	`SetScrollPos(hwnd, SB_HORZ, where, 1);`	360	`SetScrollPos(hwnd, SB_HORZ, where, 1);`
359	`where = -(where+1);`	361	`where = -(where+1);`
360	`}`	362	`}`
361	`setvalue(obj, where);`	363	`setvalue(obj, where);`
362	`activatecontrol(obj);`	364	`activatecontrol(obj);`
363	`}`	365	`}`
364		366
365	`/*`	367	`/*`
366	`* Perform some brush manipulation to handle background colours`	368	`* Perform some brush manipulation to handle background colours`
367	`* in native checkboxes and radio buttons.`	369	`* in native checkboxes and radio buttons.`
368	`*/`	370	`*/`
369	`#if USE_NATIVE_TOGGLES`	371	`#if USE_NATIVE_TOGGLES`
370	`#ifdef WM_CTLCOLOR`	372	`#ifdef WM_CTLCOLOR`
371	`static void handle_colour(HDC dc, object obj)`	373	`static void handle_colour(HDC dc, object obj)`
372	`{`	374	`{`
373	`rgb fg, bg;`	375	`rgb fg, bg;`
374	`COLORREF wincolour;`	376	`COLORREF wincolour;`
375		377
376	`if (obj->drawstate)`	378	`if (obj->drawstate)`
377	`fg = obj->drawstate->hue;`	379	`fg = obj->drawstate->hue;`
378	`else`	380	`else`
379	`fg = obj->fg;`	381	`fg = obj->fg;`
380	`wincolour = RGB((fg&Red)>>16,(fg&Green)>>8,(fg&Blue));`	382	`wincolour = RGB((fg&Red)>>16,(fg&Green)>>8,(fg&Blue));`
381	`SetTextColor(dc, wincolour);`	383	`SetTextColor(dc, wincolour);`
382		384
383	`bg = obj->bg;`	385	`bg = obj->bg;`
384	`wincolour = RGB((bg&Red)>>16,(bg&Green)>>8,(bg&Blue));`	386	`wincolour = RGB((bg&Red)>>16,(bg&Green)>>8,(bg&Blue));`
385	`SetBkColor(dc, wincolour);`	387	`SetBkColor(dc, wincolour);`
386		388
387	`fix_brush(dc, obj, obj->bgbrush);`	389	`fix_brush(dc, obj, obj->bgbrush);`
388	`}`	390	`}`
389	`#endif`	391	`#endif`
390	`#endif`	392	`#endif`
391		393
392	`static char dfilename[MAX_PATH + 1];`	394	`static char dfilename[MAX_PATH + 1];`
393	`static void handle_drop(object obj, HANDLE dropstruct)`	395	`static void handle_drop(object obj, HANDLE dropstruct)`
394	`{`	396	`{`
395	`if (obj->call && obj->call->drop) {`	397	`if (obj->call && obj->call->drop) {`
396	`int len = DragQueryFile(dropstruct, 0, NULL, 0);`	398	`int len = DragQueryFile(dropstruct, 0, NULL, 0);`
397	`if (len > MAX_PATH) {`	399	`if (len > MAX_PATH) {`
398	`DragFinish(dropstruct);`	400	`DragFinish(dropstruct);`
399	`return;`	401	`return;`
400	`}`	402	`}`
401	`DragQueryFile(dropstruct, 0, dfilename, MAX_PATH);`	403	`DragQueryFile(dropstruct, 0, dfilename, MAX_PATH);`
402	`DragFinish(dropstruct);`	404	`DragFinish(dropstruct);`
403	`obj->call->drop(obj, dfilename);`	405	`obj->call->drop(obj, dfilename);`
404	`}`	406	`}`
405	`}`	407	`}`
406		408
407	`/*`	409	`/*`
408	`* Shared window procedure code. The pass variable is initially zero.`	410	`* Shared window procedure code. The pass variable is initially zero.`
409	`* It can be set to non-zero in this procedure if we wish to pass`	411	`* It can be set to non-zero in this procedure if we wish to pass`
410	`* the event to the default Windows winprocs.`	412	`* the event to the default Windows winprocs.`
411	`*/`	413	`*/`
412	`static long handle_message(HWND hwnd, UINT message,`	414	`static long handle_message(HWND hwnd, UINT message,`
413	`WPARAM wParam, LONG lParam, int *pass)`	415	`WPARAM wParam, LONG lParam, int *pass)`
414	`{`	416	`{`
415	`object obj;`	417	`object obj;`
416		418
417	`/* Find the library object associated with the hwnd. */`	419	`/* Find the library object associated with the hwnd. */`
418	`obj = find_by_handle(hwnd);`	420	`obj = find_by_handle(hwnd);`
419		421
420	`if (! obj) { /* Not a library object ... */`	422	`if (! obj) { /* Not a library object ... */`
421	`pass = 1; / ... so pass the event. */`	423	`pass = 1; / ... so pass the event. */`
422	`return 0;`	424	`return 0;`
423	`}`	425	`}`
424		426
425	`frontwindow = obj; /* Needed for auto-mousedowns. */`	427	`frontwindow = obj; /* Needed for auto-mousedowns. */`
426		428
427	`/* Handle mouse messages. */`	429	`/* Handle mouse messages. */`
428	`if ((message >= WM_MOUSEMOVE) && (message <= WM_MBUTTONDBLCLK))`	430	`if ((message >= WM_MOUSEMOVE) && (message <= WM_MBUTTONDBLCLK))`
429	`{`	431	`{`
430	`handle_mouse(obj, hwnd, message, LOWORD(wParam),`	432	`handle_mouse(obj, hwnd, message, LOWORD(wParam),`
431	`LOWORD(lParam), HIWORD(lParam));`	433	`LOWORD(lParam), HIWORD(lParam));`
432	`return 0;`	434	`return 0;`
433	`}`	435	`}`
434		436
435	`/* Handle other messages. */`	437	`/* Handle other messages. */`
436	`switch (message)`	438	`switch (message)`
437	`{`	439	`{`
438	`case WM_KEYDOWN: /* record state of shift and control keys */`	440	`case WM_KEYDOWN: /* record state of shift and control keys */`
439	`handle_keydown(LOWORD(wParam));`	441	`handle_keydown(LOWORD(wParam));`
440	`handle_virtual_keydown(obj, LOWORD(wParam));`	442	`handle_virtual_keydown(obj, LOWORD(wParam));`
441	`break;`	443	`break;`
442		444
443	`case WM_KEYUP: /* record state of shift and control keys */`	445	`case WM_KEYUP: /* record state of shift and control keys */`
444	`handle_keyup(LOWORD(wParam));`	446	`handle_keyup(LOWORD(wParam));`
445	`break;`	447	`break;`
446		448
447	`case WM_CHAR:`	449	`case WM_CHAR:`
448	`handle_char(obj, LOWORD(wParam));`	450	`handle_char(obj, LOWORD(wParam));`
449	`return 0;`	451	`return 0;`
450		452
451	`case WM_SETFOCUS:`	453	`case WM_SETFOCUS:`
452	`handle_focus(obj, 1);`	454	`handle_focus(obj, 1);`
453	`break;`	455	`break;`
454		456
455	`case WM_KILLFOCUS:`	457	`case WM_KILLFOCUS:`
456	`handle_focus(obj, 0);`	458	`handle_focus(obj, 0);`
457	`break;`	459	`break;`
458		460
459	`case WM_PAINT:`	461	`case WM_PAINT:`
460	`handle_redraw(obj, hwnd);`	462	`handle_redraw(obj, hwnd);`
461	`return 0;`	463	`return 0;`
462		464
463	`case WM_INITMENUPOPUP:`	465	`case WM_INITMENUPOPUP:`
464	`if (HIWORD(lParam)) /* true if system menu */`	466	`if (HIWORD(lParam)) /* true if system menu */`
465	`return 0; /* else fall through */`	467	`return 0; /* else fall through */`
466	`case WM_INITMENU:`	468	`case WM_INITMENU:`
467	`adjust_menu(wParam);`	469	`adjust_menu(wParam);`
468	`break;`	470	`break;`
469		471
470	`case WM_MOVE:`	472	`case WM_MOVE:`
471	`obj->rect.x = LOWORD(lParam);`	473	`obj->rect.x = LOWORD(lParam);`
472	`obj->rect.y = HIWORD(lParam);`	474	`obj->rect.y = HIWORD(lParam);`
473	`break;`	475	`break;`
474		476
475	`case WM_SIZE:`	477	`case WM_SIZE:`
476	`obj->rect.width = LOWORD(lParam);`	478	`obj->rect.width = LOWORD(lParam);`
477	`obj->rect.height = HIWORD(lParam);`	479	`obj->rect.height = HIWORD(lParam);`
478	`handle_resize(obj);`	480	`handle_resize(obj);`
479	`break;`	481	`break;`
480		482
481	`case WM_ACTIVATE:`	483	`case WM_ACTIVATE:`
482	`/* Keep track of which window is in front. */`	484	`/* Keep track of which window is in front. */`
483	`if (LOWORD(wParam) != WA_INACTIVE)`	485	`if (LOWORD(wParam) != WA_INACTIVE)`
484	`move_to_front(obj);`	486	`move_to_front(obj);`
485	`break;`	487	`break;`
486		488
487	`case WM_QUERYENDSESSION:`	489	`case WM_QUERYENDSESSION:`
488	`handle_close(obj);`	490	`handle_close(obj);`
489	`return 1L; /* ensure Windows can terminate */`	491	`return 1L; /* ensure Windows can terminate */`
490		492
491	`case WM_CLOSE:`	493	`case WM_CLOSE:`
492	`handle_close(obj);`	494	`handle_close(obj);`
493	`return 0;`	495	`return 0;`
494		496
495	`case WM_DESTROY:`	497	`case WM_DESTROY:`
496	`handle_destroy(obj);`	498	`handle_destroy(obj);`
497	`break;`	499	`break;`
498		500

The R Project SVN R

(root)/trunk/src/gnuwin32/graphapp/events.c @ 28362 – Rev 24283 → 24322