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


/*
 * GraphApp - Cross-Platform Graphics Programming Library.
 *
 * File: controls.c -- manipulating scrollbars, buttons, etc.
 * Platform: Windows  Version: 2.40  Date: 1998/04/04
 *
 * Version: 1.00  Changes: Original version by Lachlan Patrick.
 * Version: 1.60  Changes: Added clear(), draw(), flashcontrol().
 * Version: 2.00  Changes: New object class system.
 * Version: 2.15  Changes: Transparent backgrounds added.
 * Version: 2.20  Changes: Non-native buttons supported.
 * Version: 2.35  Changes: New reference count technique.
 * Version: 2.40  Changes: Support for new controls.
 */
 
/* 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.
*/
 
/*  Copyright (C) 2004 	The R Foundation
 
    Changes for R:
 
    sort out resize (confused screen and client coords)
    add printer and metafile handling
    Remove assumption of current->dest being non-NULL
 
 */
 
#include "internal.h"
 
/*
 *  Setting control call-backs.
 */
void setaction(control obj, actionfn fn)
{
	if (obj)
		obj->action = fn;
}
 
void sethit(control obj, intfn fn)
{
	if (obj)
		obj->hit = fn;
}
 
void setdel(control obj, actionfn fn)
{
	if (obj)
		if (obj->call)
			obj->call->die = fn;
}
 
void setclose(control obj, actionfn fn)
{
	if (obj)
		if (obj->call)
			obj->call->close = fn;
}
 
void setredraw(control obj, drawfn fn)
{
	if (obj)
		if (obj->call)
			obj->call->redraw = fn;
}
 
void setresize(control obj, drawfn fn)
{
	if (obj)
		if (obj->call)
			obj->call->resize = fn;
}
 
void setkeydown(control obj, keyfn fn)
{
	if (obj)
		if (obj->call)
			obj->call->keydown = fn;
}
 
void setkeyaction(control obj, keyfn fn)
{
	if (obj)
		if (obj->call)
			obj->call->keyaction = fn;
}
 
void setmousedown(control obj, mousefn fn)
{
	if (obj)
		if (obj->call)
			obj->call->mousedown = fn;
}
 
void setmouseup(control obj, mousefn fn)
{
	if (obj)
		if (obj->call)
			obj->call->mouseup = fn;
}
 
void setmousemove(control obj, mousefn fn)
{
	if (obj)
		if (obj->call)
			obj->call->mousemove = fn;
}
 
void setmousedrag(control obj, mousefn fn)
{
	if (obj)
		if (obj->call)
			obj->call->mousedrag = fn;
}
 
void setmouserepeat(control obj, mousefn fn)
{
	if (obj)
		if (obj->call)
			obj->call->mouserepeat = fn;
}
 
void setdrop(control obj, dropfn fn)
{
	if (obj)
	    if (obj->call) {
		DragAcceptFiles(obj->handle, TRUE);
		obj->call->drop = fn;
	    }
}
 
void setonfocus(control obj, actionfn fn)
{
	if (obj)
		obj->call->focus = fn;
}
 
 
/*
 *  Drawing controls and windows.
 */
void clear(control obj)
{
	drawing prev;
	rgb old;
 
	if (! obj)
		return;
	if (! isvisible(obj))
		return;
	if (! isvisible(parentwindow(obj)))
		return;
	if (obj->bg == Transparent)
		return;
	prev = current->dest;
	drawto(obj);
	old = currentrgb();
	setrgb(obj->bg);
	fillrect(getrect(obj));
	if (prev) {
		setrgb(old);
		drawto(prev);
    	}
}
 
void draw(control obj)
{
	drawing prev;
	drawstate old;
 
	if (! obj)
		return;
	if (obj->kind == MenubarObject) {
		DrawMenuBar(obj->parent->handle);
		return;
	}
 
	if (! isvisible(obj))
		return;
	if (! isvisible(parentwindow(obj)))
		return;
	if ((obj->call == NULL) || (obj->call->redraw == NULL))
		return;
	prev = current->dest;
	drawto(obj);
	if (prev) old = copydrawstate();
	moveto(pt(0,0));
	obj->call->redraw(obj, getrect(obj));
	if (prev) {
		restoredrawstate(old);
		drawto(prev);
    	}
}
 
void redraw(control obj)
{
	clear(obj);
	draw(obj);
}
 
/*  void getscreenrect(control obj, rect *r) */
/*  { */
/*      RECT W; */
/*      GetWindowRect(obj->handle, &W); */
/*      r->x = W.left; */
/*      r->y = W.top; */
/*      r->width = W.right - W.left; */
/*      r->height = W.bottom - W.top; */
/*  } */
 
 
/* The original here used GetWindowRect (which used screen coordinates)
   and MoveWindow (which uses client coordinates) so got the positioning
   hopelessly wrong.  This version works for WindowObjects, but I would be
   suspicious of it for other cases.  BDR 2000/04/05
*/
void resize(control obj, rect r)
{
        RECT R;
	WINDOWPLACEMENT W;
	int dw, dh, dx, dy;
 
	if (! obj)
		return;
	r = rcanon(r);
	if (obj->kind == WindowObject) {
	        W.length = sizeof(WINDOWPLACEMENT);
		r.x = obj->rect.x;
		r.y = obj->rect.y;
		if (!equalr(r, obj->rect)) {
			GetWindowPlacement(obj->handle, &W);
			if (!isvisible(obj)) W.showCmd = SW_HIDE;  /* stops the resize from revealing the window */
			dx = r.x - obj->rect.x;
			dy = r.y - obj->rect.y;
			/* don't believe current sizes!
			dw = r.width - obj->rect.width;
			dh = r.height - obj->rect.height;
			Rprintf("dw %d dh %d\n", dw, dh); */
			GetClientRect(obj->handle, &R);
			dw = r.width - (R.right - R.left);
			dh = r.height - (R.bottom - R.top);
			W.rcNormalPosition.left += dx;
			W.rcNormalPosition.top += dy;
			W.rcNormalPosition.right += dx + dw;
			W.rcNormalPosition.bottom += dy + dh;
			SetWindowPlacement(obj->handle, &W);
		}
	}
	else {
		if (! equalr(r, obj->rect))
			MoveWindow(obj->handle, r.x, r.y, r.width, r.height, 1);
		obj->rect.x = r.x;
		obj->rect.y = r.y;
	}
	obj->rect.width = r.width;
	obj->rect.height = r.height;
}
 
/*
 *  Showing and hiding controls and windows.
 */
void show(control obj)
{
	if (! obj)
		return;
	switch (obj->kind)
	{
	case CursorObject: case FontObject: case BitmapObject:
	case MenubarObject: case MenuObject: case MenuitemObject:
		break;
	case WindowObject:
		obj->state |= Visible;
		show_window(obj);
		break;
	default:
		ShowWindow(obj->handle, SW_SHOWNORMAL);
		SetFocus(obj->handle);
		UpdateWindow(obj->handle);
	}
	obj->state |= Visible;
}
 
void hide(control obj)
{
	if (! obj)
		return;
	switch (obj->kind)
	{
	case CursorObject: case FontObject: case BitmapObject:
	case MenubarObject: case MenuObject: case MenuitemObject:
		break;
	case WindowObject:
		hide_window(obj);
		break;
	default:
		ShowWindow(obj->handle, SW_HIDE);
	}
	obj->state &= ~Visible;
}
 
int isvisible(control obj)
{
	if (! obj)
		return 0;
	return (obj->state & Visible) ? 1 : 0;
}
 
/*
 *  Enabling and disabling controls and windows.
 */
void enable(control obj)
{
	if (! obj)
		return;
	switch (obj->kind)
	{
	case CursorObject: case FontObject: case BitmapObject:
	case MenubarObject:
		break;
	case MenuObject: case MenuitemObject:
		EnableMenuItem(obj->parent->handle,
			obj->id, MF_ENABLED | MF_BYCOMMAND);
		break;
	case FieldObject: case TextboxObject:
		sendmessage(obj->handle, EM_SETREADONLY, FALSE, 0L);
		break;
	default:
		if (! isenabled(obj)) {
			EnableWindow(obj->handle, 1);
			obj->state |= Enabled;
			draw(obj);
		}
	}
	obj->state |= Enabled;
}
 
void disable(control obj)
{
	if (! obj)
		return;
	switch (obj->kind)
	{
	case CursorObject: case FontObject: case BitmapObject:
	case MenubarObject: case MenuObject:
		break;
	case MenuitemObject:
		EnableMenuItem(obj->parent->handle,
			obj->id, MF_GRAYED | MF_BYCOMMAND);
		break;
	case FieldObject: case TextboxObject:
		sendmessage(obj->handle, EM_SETREADONLY, TRUE, 0L);
		break;
	default:
		if (isenabled(obj)) {
			EnableWindow(obj->handle, 0);
			obj->state &= ~Enabled;
			draw(obj);
		}
	}
	obj->state &= ~Enabled;
}
 
int isenabled(control obj)
{
	if (! obj)
		return 0;
	return (obj->state & Enabled) ? 1 : 0;
}
 
/*
 *  Checking and unchecking controls.
 */
void check(control obj)
{
	if (! obj)
		return;
	switch (obj->kind)
	{
	case CursorObject: case FontObject: case BitmapObject:
	case MenubarObject: case MenuObject:
		break;
	case MenuitemObject:
		CheckMenuItem(obj->parent->handle, obj->id,
			MF_CHECKED | MF_BYCOMMAND);
		break;
#if USE_NATIVE_BUTTONS
	case ButtonObject:
		sendmessage(obj->handle, BM_SETCHECK, 1, 0L);
		break;
#endif
#if USE_NATIVE_TOGGLES
	case CheckboxObject: case RadioObject:
		sendmessage(obj->handle, BM_SETCHECK, 1, 0L);
		break;
#endif
	default:
		if (! ischecked(obj)) {
			obj->state |= Checked;
			draw(obj);
		}
	}
	obj->state |= Checked;
}
 
void uncheck(control obj)
{
	if (! obj)
		return;
	switch (obj->kind)
	{
	case CursorObject: case FontObject: case BitmapObject:
	case MenubarObject: case MenuObject:
		break;
	case MenuitemObject:
		CheckMenuItem(obj->parent->handle, obj->id,
			MF_UNCHECKED | MF_BYCOMMAND);
		break;
#if USE_NATIVE_BUTTONS
	case ButtonObject:
		sendmessage(obj->handle, BM_SETCHECK, 0, 0L);
		break;
#endif
#if USE_NATIVE_TOGGLES
	case CheckboxObject: case RadioObject:
		sendmessage(obj->handle, BM_SETCHECK, 0, 0L);
		break;
#endif
	default:
		if (ischecked(obj)) {
			obj->state &= ~Checked;
			draw(obj);
		}
	}
	obj->state &= ~Checked;
}
 
int ischecked(control obj)
{
	if (! obj)
		return 0;
	return (obj->state & Checked) ? 1 : 0;
}
 
/*
 *  Highlighting and unhighlighting controls.
 */
void highlight(control obj)
{
	if (! obj)
		return;
	switch (obj->kind)
	{
	case CursorObject: case FontObject: case BitmapObject:
	case MenubarObject: case MenuObject: case MenuitemObject:
		break;
#if USE_NATIVE_BUTTONS
	case ButtonObject:
		sendmessage(obj->handle, BM_SETSTATE, 1, 0L);
		break;
#endif
#if USE_NATIVE_TOGGLES
	case CheckboxObject: case RadioObject:
		sendmessage(obj->handle, BM_SETSTATE, 1, 0L);
		break;
#endif
	case FieldObject: case TextboxObject:
		sendmessage(obj->handle, EM_SETSEL, 0, MAKELONG(0,-1));
		break;
	default:
		if (! ishighlighted(obj)) {
			obj->state |= Highlighted;
			draw(obj);
		}
	}
	obj->state |= Highlighted;
}
 
void unhighlight(control obj)
{
	if (! obj)
		return;
	switch (obj->kind)
	{
	case CursorObject: case FontObject: case BitmapObject:
	case MenubarObject: case MenuObject: case MenuitemObject:
		break;
#if USE_NATIVE_BUTTONS
	case ButtonObject:
		sendmessage(obj->handle, BM_SETSTATE, 0, 0L);
		break;
#endif
#if USE_NATIVE_TOGGLES
	case CheckboxObject: case RadioObject:
		sendmessage(obj->handle, BM_SETSTATE, 0, 0L);
		break;
#endif
	case FieldObject: case TextboxObject:
		sendmessage(obj->handle, EM_SETSEL, 0, MAKELONG(0,0));
		break;
	default:
		if (ishighlighted(obj)) {
			obj->state &= ~Highlighted;
			draw(obj);
		}
	}
	obj->state &= ~Highlighted;
}
 
int ishighlighted(control obj)
{
	if (! obj)
		return 0;
	return (obj->state & Highlighted) ? 1 : 0;
}
 
/*
 *  The flashcontrol function highlights a control as if the user
 *  just used it, e.g. a button will become pressed down for a
 *  moment. Used in conjunction with activatecontrol() below,
 *  it can simulate a mouse-click on a button.
 */
void flashcontrol(control obj)
{
	highlight(obj);
	delay(150);
	unhighlight(obj);
}
 
/*
 *  The activatecontrol function is really useful. It causes
 *  a variety of controls to call their 'action functions.'
 *
 *  There are two types of action functions which a control can use.
 *  The first (obj->action) takes one argument, the control itself,
 *  and is used in buttons, checkboxes and the like as a response
 *  to a user clicking on these controls. The second function,
 *  (obj->hit) function, takes two arguments: the control and its
 *  current 'value'. A scrollbar's value changes as the user scrolls,
 *  and so its hit function is called whenever that happens.
 *
 *  The activatecontrol function tries to call the action function,
 *  and if that doesn't exist, calls the hit function, passing the
 *  object's value to it.
 */
void activatecontrol(control obj)
{
	if (! obj)
		return;
	drawto(obj);
	if (obj->action != NULL)
		obj->action(obj);
	else if (obj->hit != NULL)
		obj->hit(obj, obj->value);
}
 
/*
 *  Changing and determining the state of an object.
 *  These functions do not automatically redraw the object.
 */
#if 0
void setstate(control obj, long state)
{
	if (obj)
		obj->state = state;
}
 
long getstate(control obj)
{
	if (obj)
		return obj->state;
	else
		return 0;
}
#endif
 
void setvalue(control obj, int value)
{
	if (obj)
		obj->value = value;
}
 
int getvalue(control obj)
{
	if (obj)
		return obj->value;
	else
		return 0;
}
 
void setforeground(control obj, rgb fg)
{
	if (! obj)
		return;
	obj->fg = fg;
	InvalidateRect(obj->handle, NULL, TRUE);
	redraw(obj);
}
 
rgb getforeground(control obj)
{
	if (obj)
		return obj->fg;
	else
		return Black;
}
 
void setbackground(control obj, rgb bg)
{
#if USE_NATIVE_CONTROLS
	COLORREF wincolour;
 
	wincolour = RGB((bg&gaRed)>>16,(bg&gaGreen)>>8,(bg&gaBlue));
 
	if (! obj)
		return;
	if (obj->bgbrush)
		DeleteObject(obj->bgbrush);
	obj->bgbrush = CreateSolidBrush(wincolour);
#endif
	if (! obj)
		return;
	obj->bg = bg;
	InvalidateRect(obj->handle, NULL, TRUE);
	redraw(obj);
}
 
rgb getbackground(control obj)
{
	if (obj)
		return obj->bg;
	else
		return Transparent;
}
 
void setdata(control obj, void *data)
{
	if (obj)
		obj->data = data;
}
 
void *getdata(control obj)
{
	if (obj)
		return obj->data;
	else
		return NULL;
}
 
void _setextradata(control obj, void *data)
{
	if (obj)
		obj->extra = data;
}
 
void *_getextradata(control obj)
{
	if (obj)
		return obj->extra;
	else
		return NULL;
}
 
/*
 *  Set the text of an object. This will set the names appearing
 *  in a window's title bar, a button, checkbox or radio button,
 *  or the value in a textbox or a text field.
 */
void settext(control obj, char *text)
{
	if (! obj)
		return;
	if (! text)
		text = "";
	if (strcmp(gettext(obj), text) == 0)
		return; /* no changes to be made */
	if (obj->text) {
		/* discard prior information */
		discard(obj->text);
		obj->text = NULL;
	}
	/* Set the new text. */
	obj->text = new_string(text);
	if (text) {
		if (obj->kind & ControlObject) {
			text = to_dos_string(text);
			SetWindowText(obj->handle, text);
			discard(text);
		}
                if (obj->kind==MenuitemObject) {
                        ModifyMenu(obj->parent->handle, obj->id,
                                   MF_BYCOMMAND|MF_STRING,obj->id,
                                   text);
                }
 
	}
	/* Redraw it if it's a redrawable object. */
	if (obj->call && obj->call->redraw)
		redraw(obj);
}
 
/*
 *  Get the text string from a window's title bar or from a
 *  control. This may be a button's name, for example, or
 *  the value inside a text field.
 */
char *gettext(control obj)
{
	static char *empty = "";
	char *text;
	int length, index;
	HWND hwnd;
	UINT len_msg, gettext_msg;
	WPARAM arg1, arg2;
 
	if (! obj)
		return empty;
	if ((obj->kind & ControlObject) == 0)
		return obj->text ? obj->text : empty;
 
	hwnd = obj->handle;
 
	switch (obj->kind) {
	  case ListboxObject:
	  case MultilistObject:
		len_msg = LB_GETTEXTLEN;
		gettext_msg = LB_GETTEXT;
		index = getlistitem(obj);
		if (index < 0) return empty;
		arg1 = arg2 = index;
		break;
	  case DroplistObject:
		len_msg = CB_GETLBTEXTLEN;
		gettext_msg = CB_GETLBTEXT;
		index = getlistitem(obj);
		if (index < 0) return empty;
		arg1 = arg2 = index;
		break;
	  case DropfieldObject:
		// use default mechanism
	  default:
		len_msg = WM_GETTEXTLENGTH;
		gettext_msg = WM_GETTEXT;
		arg1 = 0;
		arg2 = sendmessage(hwnd, len_msg, 0, 0L)+1;
		break;
	}
 
	/* Free any previous information. */
	if (obj->text)
	    discard(obj->text);
	/* Find the length of the string. */
	length = sendmessage(obj->handle, len_msg, arg1, 0L);
	if (length == 0)
		return (obj->text = new_string(NULL));
	/* Copy the text from the object. */
	text = array(length+2, char);
	sendmessage(obj->handle, gettext_msg, arg2, (LPCSTR) text);
	obj->text = to_c_string(text);
	discard(text);
	/* Return the resultant string. */
	if (! obj->text)
		obj->text = new_string(NULL);
	return obj->text;
}
 
/*
 *  Set the font used by a control.
 */
void settextfont(object obj, font f)
{
	if (! obj)
		return;
	if (! f)
		f = SystemFont;
	if (obj->drawstate) {
		decrease_refcount(obj->drawstate->fnt);
		obj->drawstate->fnt = f;
		increase_refcount(f);
	}
	else {
		sendmessage(obj->handle, WM_SETFONT, f->handle, 0L);
	}
}
 
/*
 *  Get the font used by a control.
 */
font gettextfont(object obj)
{
	font f = NULL;
	if (obj) {
		if (obj->drawstate)
			f = obj->drawstate->fnt;
	}
	if (! f)
		f = SystemFont;
	return f;
}
 
/*
 *  Control and window functions.
 *  Parentwindow of a window is itself.
 */
window parentwindow(control obj)
{
	while (obj) {
		if (obj->kind == WindowObject)
			break;
		obj = obj->parent;
	}
	return (window) obj;
}
 
/*
 *  Polymorphic functions:
 */
rect objrect(object obj)
{
	rect r;
	image img;
 
	if (! obj)
		return rect(0,0,0,0);
 
	switch (obj->kind)
	{
	  case Image8: case Image32:
		img = (image) obj;
		r = rect(0,0,img->width,img->height);
		break;
	  case BitmapObject:
	  case FontObject: case CursorObject:
	 case PrinterObject:
		r = obj->rect;
		break;
	 case MetafileObject:
		r = obj->rect;
		break;
	  default:
		GetClientRect(obj->handle, (RECT *) &r);
		break;
	}
	return r;
}
 
int objwidth(object obj)
{
	rect r = objrect(obj);
	return r.width;
}
 
int objheight(object obj)
{
	rect r = objrect(obj);
	return r.height;
}
 
int objdepth(object obj)
{
	HDC screendc;
	int depth;
 
	if (! obj)
		return 0;
 
	switch (obj->kind)
	{
	  case Image8: case Image32:
		depth = ((image)obj)->depth;
		break;
	  case BitmapObject:
	  case FontObject: case CursorObject:
		depth = obj->depth;
		break;
	  default:
		screendc = GetDC(NULL);
		depth = GetDeviceCaps(screendc, BITSPIXEL) *
			GetDeviceCaps(screendc, PLANES);
		ReleaseDC(NULL, screendc);
		break;
	}
 
	return depth;
}
 
void delobj(object obj)
{
	if (! obj)
		return;
	switch (obj->kind)
	{
	  case Image8:
	  case Image32:
		delimage((image)obj);
		break;
	  default:
		/* if (obj->refcount == 1)   why would this test be here?? */
			decrease_refcount(obj);
		break;
	}
}

Rev 28991	Rev 31702
1	`/*`	1	`/*`
2	`* GraphApp - Cross-Platform Graphics Programming Library.`	2	`* GraphApp - Cross-Platform Graphics Programming Library.`
3	`*`	3	`*`
4	`* File: controls.c -- manipulating scrollbars, buttons, etc.`	4	`* File: controls.c -- manipulating scrollbars, buttons, etc.`
5	`* Platform: Windows Version: 2.40 Date: 1998/04/04`	5	`* Platform: Windows Version: 2.40 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: 1.60 Changes: Added clear(), draw(), flashcontrol().`	8	`* Version: 1.60 Changes: Added clear(), draw(), flashcontrol().`
9	`* Version: 2.00 Changes: New object class system.`	9	`* Version: 2.00 Changes: New object class system.`
10	`* Version: 2.15 Changes: Transparent backgrounds added.`	10	`* Version: 2.15 Changes: Transparent backgrounds added.`
11	`* Version: 2.20 Changes: Non-native buttons supported.`	11	`* Version: 2.20 Changes: Non-native buttons supported.`
12	`* Version: 2.35 Changes: New reference count technique.`	12	`* Version: 2.35 Changes: New reference count technique.`
13	`* Version: 2.40 Changes: Support for new controls.`	13	`* Version: 2.40 Changes: Support for new controls.`
14	`*/`	14	`*/`
15		15
16	`/* Copyright (C) 1993-1998 Lachlan Patrick`	16	`/* Copyright (C) 1993-1998 Lachlan Patrick`
17		17
18	`This file is part of GraphApp, a cross-platform C graphics library.`	18	`This file is part of GraphApp, a cross-platform C graphics library.`
19		19
20	`GraphApp is free software; you can redistribute it and/or modify it`	20	`GraphApp is free software; you can redistribute it and/or modify it`
21	`under the terms of the GNU Library General Public License.`	21	`under the terms of the GNU Library General Public License.`
22	`GraphApp is distributed in the hope that it will be useful, but`	22	`GraphApp is distributed in the hope that it will be useful, but`
23	`WITHOUT ANY WARRANTY.`	23	`WITHOUT ANY WARRANTY.`
24		24
25	`See the file COPYLIB.TXT for details.`	25	`See the file COPYLIB.TXT for details.`
26	`*/`	26	`*/`
27		27
28	`/* Copyright (C) 2004 The R Foundation`	28	`/* Copyright (C) 2004 The R Foundation`
29		29
30	`Changes for R:`	30	`Changes for R:`
31		31
32	`sort out resize (confused screen and client coords)`	32	`sort out resize (confused screen and client coords)`
33	`add printer and metafile handling`	33	`add printer and metafile handling`
-		34	`Remove assumption of current->dest being non-NULL`
34		35
35	`*/`	36	`*/`
36		37
37	`#include "internal.h"`	38	`#include "internal.h"`
38		39
39	`/*`	40	`/*`
40	`* Setting control call-backs.`	41	`* Setting control call-backs.`
41	`*/`	42	`*/`
42	`void setaction(control obj, actionfn fn)`	43	`void setaction(control obj, actionfn fn)`
43	`{`	44	`{`
44	`if (obj)`	45	`if (obj)`
45	`obj->action = fn;`	46	`obj->action = fn;`
46	`}`	47	`}`
47		48
48	`void sethit(control obj, intfn fn)`	49	`void sethit(control obj, intfn fn)`
49	`{`	50	`{`
50	`if (obj)`	51	`if (obj)`
51	`obj->hit = fn;`	52	`obj->hit = fn;`
52	`}`	53	`}`
53		54
54	`void setdel(control obj, actionfn fn)`	55	`void setdel(control obj, actionfn fn)`
55	`{`	56	`{`
56	`if (obj)`	57	`if (obj)`
57	`if (obj->call)`	58	`if (obj->call)`
58	`obj->call->die = fn;`	59	`obj->call->die = fn;`
59	`}`	60	`}`
60		61
61	`void setclose(control obj, actionfn fn)`	62	`void setclose(control obj, actionfn fn)`
62	`{`	63	`{`
63	`if (obj)`	64	`if (obj)`
64	`if (obj->call)`	65	`if (obj->call)`
65	`obj->call->close = fn;`	66	`obj->call->close = fn;`
66	`}`	67	`}`
67		68
68	`void setredraw(control obj, drawfn fn)`	69	`void setredraw(control obj, drawfn fn)`
69	`{`	70	`{`
70	`if (obj)`	71	`if (obj)`
71	`if (obj->call)`	72	`if (obj->call)`
72	`obj->call->redraw = fn;`	73	`obj->call->redraw = fn;`
73	`}`	74	`}`
74		75
75	`void setresize(control obj, drawfn fn)`	76	`void setresize(control obj, drawfn fn)`
76	`{`	77	`{`
77	`if (obj)`	78	`if (obj)`
78	`if (obj->call)`	79	`if (obj->call)`
79	`obj->call->resize = fn;`	80	`obj->call->resize = fn;`
80	`}`	81	`}`
81		82
82	`void setkeydown(control obj, keyfn fn)`	83	`void setkeydown(control obj, keyfn fn)`
83	`{`	84	`{`
84	`if (obj)`	85	`if (obj)`
85	`if (obj->call)`	86	`if (obj->call)`
86	`obj->call->keydown = fn;`	87	`obj->call->keydown = fn;`
87	`}`	88	`}`
88		89
89	`void setkeyaction(control obj, keyfn fn)`	90	`void setkeyaction(control obj, keyfn fn)`
90	`{`	91	`{`
91	`if (obj)`	92	`if (obj)`
92	`if (obj->call)`	93	`if (obj->call)`
93	`obj->call->keyaction = fn;`	94	`obj->call->keyaction = fn;`
94	`}`	95	`}`
95		96
96	`void setmousedown(control obj, mousefn fn)`	97	`void setmousedown(control obj, mousefn fn)`
97	`{`	98	`{`
98	`if (obj)`	99	`if (obj)`
99	`if (obj->call)`	100	`if (obj->call)`
100	`obj->call->mousedown = fn;`	101	`obj->call->mousedown = fn;`
101	`}`	102	`}`
102		103
103	`void setmouseup(control obj, mousefn fn)`	104	`void setmouseup(control obj, mousefn fn)`
104	`{`	105	`{`
105	`if (obj)`	106	`if (obj)`
106	`if (obj->call)`	107	`if (obj->call)`
107	`obj->call->mouseup = fn;`	108	`obj->call->mouseup = fn;`
108	`}`	109	`}`
109		110
110	`void setmousemove(control obj, mousefn fn)`	111	`void setmousemove(control obj, mousefn fn)`
111	`{`	112	`{`
112	`if (obj)`	113	`if (obj)`
113	`if (obj->call)`	114	`if (obj->call)`
114	`obj->call->mousemove = fn;`	115	`obj->call->mousemove = fn;`
115	`}`	116	`}`
116		117
117	`void setmousedrag(control obj, mousefn fn)`	118	`void setmousedrag(control obj, mousefn fn)`
118	`{`	119	`{`
119	`if (obj)`	120	`if (obj)`
120	`if (obj->call)`	121	`if (obj->call)`
121	`obj->call->mousedrag = fn;`	122	`obj->call->mousedrag = fn;`
122	`}`	123	`}`
123		124
124	`void setmouserepeat(control obj, mousefn fn)`	125	`void setmouserepeat(control obj, mousefn fn)`
125	`{`	126	`{`
126	`if (obj)`	127	`if (obj)`
127	`if (obj->call)`	128	`if (obj->call)`
128	`obj->call->mouserepeat = fn;`	129	`obj->call->mouserepeat = fn;`
129	`}`	130	`}`
130		131
131	`void setdrop(control obj, dropfn fn)`	132	`void setdrop(control obj, dropfn fn)`
132	`{`	133	`{`
133	`if (obj)`	134	`if (obj)`
134	`if (obj->call) {`	135	`if (obj->call) {`
135	`DragAcceptFiles(obj->handle, TRUE);`	136	`DragAcceptFiles(obj->handle, TRUE);`
136	`obj->call->drop = fn;`	137	`obj->call->drop = fn;`
137	`}`	138	`}`
138	`}`	139	`}`
139		140
140	`void setonfocus(control obj, actionfn fn)`	141	`void setonfocus(control obj, actionfn fn)`
141	`{`	142	`{`
142	`if (obj)`	143	`if (obj)`
143	`obj->call->focus = fn;`	144	`obj->call->focus = fn;`
144	`}`	145	`}`
145		146
146		147
147	`/*`	148	`/*`
148	`* Drawing controls and windows.`	149	`* Drawing controls and windows.`
149	`*/`	150	`*/`
150	`void clear(control obj)`	151	`void clear(control obj)`
151	`{`	152	`{`
152	`drawing prev;`	153	`drawing prev;`
153	`rgb old;`	154	`rgb old;`
154		155
155	`if (! obj)`	156	`if (! obj)`
156	`return;`	157	`return;`
157	`if (! isvisible(obj))`	158	`if (! isvisible(obj))`
158	`return;`	159	`return;`
159	`if (! isvisible(parentwindow(obj)))`	160	`if (! isvisible(parentwindow(obj)))`
160	`return;`	161	`return;`
161	`if (obj->bg == Transparent)`	162	`if (obj->bg == Transparent)`
162	`return;`	163	`return;`
163	`prev = current->dest;`	164	`prev = current->dest;`
164	`drawto(obj);`	165	`drawto(obj);`
165	`old = currentrgb();`	166	`old = currentrgb();`
166	`setrgb(obj->bg);`	167	`setrgb(obj->bg);`
167	`fillrect(getrect(obj));`	168	`fillrect(getrect(obj));`
-		169	`if (prev) {`
168	`setrgb(old);`	170	`setrgb(old);`
169	`drawto(prev);`	171	`drawto(prev);`
-		172	`}`
170	`}`	173	`}`
171		174
172	`void draw(control obj)`	175	`void draw(control obj)`
173	`{`	176	`{`
174	`drawing prev;`	177	`drawing prev;`
175	`drawstate old;`	178	`drawstate old;`
176		179
177	`if (! obj)`	180	`if (! obj)`
178	`return;`	181	`return;`
179	`if (obj->kind == MenubarObject) {`	182	`if (obj->kind == MenubarObject) {`
180	`DrawMenuBar(obj->parent->handle);`	183	`DrawMenuBar(obj->parent->handle);`
181	`return;`	184	`return;`
182	`}`	185	`}`
183		186
184	`if (! isvisible(obj))`	187	`if (! isvisible(obj))`
185	`return;`	188	`return;`
186	`if (! isvisible(parentwindow(obj)))`	189	`if (! isvisible(parentwindow(obj)))`
187	`return;`	190	`return;`
188	`if ((obj->call == NULL) \|\| (obj->call->redraw == NULL))`	191	`if ((obj->call == NULL) \|\| (obj->call->redraw == NULL))`
189	`return;`	192	`return;`
190	`prev = current->dest;`	193	`prev = current->dest;`
191	`drawto(obj);`	194	`drawto(obj);`
192	`old = copydrawstate();`	195	`if (prev) old = copydrawstate();`
193	`moveto(pt(0,0));`	196	`moveto(pt(0,0));`
194	`obj->call->redraw(obj, getrect(obj));`	197	`obj->call->redraw(obj, getrect(obj));`
-		198	`if (prev) {`
195	`restoredrawstate(old);`	199	`restoredrawstate(old);`
196	`drawto(prev);`	200	`drawto(prev);`
-		201	`}`
197	`}`	202	`}`
198		203
199	`void redraw(control obj)`	204	`void redraw(control obj)`
200	`{`	205	`{`
201	`clear(obj);`	206	`clear(obj);`
202	`draw(obj);`	207	`draw(obj);`
203	`}`	208	`}`
204		209
205	`/* void getscreenrect(control obj, rect r) /`	210	`/* void getscreenrect(control obj, rect r) /`
206	`/* { */`	211	`/* { */`
207	`/* RECT W; */`	212	`/* RECT W; */`
208	`/* GetWindowRect(obj->handle, &W); */`	213	`/* GetWindowRect(obj->handle, &W); */`
209	`/* r->x = W.left; */`	214	`/* r->x = W.left; */`
210	`/* r->y = W.top; */`	215	`/* r->y = W.top; */`
211	`/* r->width = W.right - W.left; */`	216	`/* r->width = W.right - W.left; */`
212	`/* r->height = W.bottom - W.top; */`	217	`/* r->height = W.bottom - W.top; */`
213	`/* } */`	218	`/* } */`
214		219
215		220
216	`/* The original here used GetWindowRect (which used screen coordinates)`	221	`/* The original here used GetWindowRect (which used screen coordinates)`
217	`and MoveWindow (which uses client coordinates) so got the positioning`	222	`and MoveWindow (which uses client coordinates) so got the positioning`
218	`hopelessly wrong. This version works for WindowObjects, but I would be`	223	`hopelessly wrong. This version works for WindowObjects, but I would be`
219	`suspicious of it for other cases. BDR 2000/04/05`	224	`suspicious of it for other cases. BDR 2000/04/05`
220	`*/`	225	`*/`
221	`void resize(control obj, rect r)`	226	`void resize(control obj, rect r)`
222	`{`	227	`{`
223	`RECT R;`	228	`RECT R;`
224	`WINDOWPLACEMENT W;`	229	`WINDOWPLACEMENT W;`
225	`int dw, dh, dx, dy;`	230	`int dw, dh, dx, dy;`
226		231
227	`if (! obj)`	232	`if (! obj)`
228	`return;`	233	`return;`
229	`r = rcanon(r);`	234	`r = rcanon(r);`
230	`if (obj->kind == WindowObject) {`	235	`if (obj->kind == WindowObject) {`
231	`W.length = sizeof(WINDOWPLACEMENT);`	236	`W.length = sizeof(WINDOWPLACEMENT);`
232	`r.x = obj->rect.x;`	237	`r.x = obj->rect.x;`
233	`r.y = obj->rect.y;`	238	`r.y = obj->rect.y;`
234	`if (!equalr(r, obj->rect)) {`	239	`if (!equalr(r, obj->rect)) {`
235	`GetWindowPlacement(obj->handle, &W);`	240	`GetWindowPlacement(obj->handle, &W);`
236	`if (!isvisible(obj)) W.showCmd = SW_HIDE; /* stops the resize from revealing the window */`	241	`if (!isvisible(obj)) W.showCmd = SW_HIDE; /* stops the resize from revealing the window */`
237	`dx = r.x - obj->rect.x;`	242	`dx = r.x - obj->rect.x;`
238	`dy = r.y - obj->rect.y;`	243	`dy = r.y - obj->rect.y;`
239	`/* don't believe current sizes!`	244	`/* don't believe current sizes!`
240	`dw = r.width - obj->rect.width;`	245	`dw = r.width - obj->rect.width;`
241	`dh = r.height - obj->rect.height;`	246	`dh = r.height - obj->rect.height;`
242	`Rprintf("dw %d dh %d\n", dw, dh); */`	247	`Rprintf("dw %d dh %d\n", dw, dh); */`
243	`GetClientRect(obj->handle, &R);`	248	`GetClientRect(obj->handle, &R);`
244	`dw = r.width - (R.right - R.left);`	249	`dw = r.width - (R.right - R.left);`
245	`dh = r.height - (R.bottom - R.top);`	250	`dh = r.height - (R.bottom - R.top);`
246	`W.rcNormalPosition.left += dx;`	251	`W.rcNormalPosition.left += dx;`
247	`W.rcNormalPosition.top += dy;`	252	`W.rcNormalPosition.top += dy;`
248	`W.rcNormalPosition.right += dx + dw;`	253	`W.rcNormalPosition.right += dx + dw;`
249	`W.rcNormalPosition.bottom += dy + dh;`	254	`W.rcNormalPosition.bottom += dy + dh;`
250	`SetWindowPlacement(obj->handle, &W);`	255	`SetWindowPlacement(obj->handle, &W);`
251	`}`	256	`}`
252	`}`	257	`}`
253	`else {`	258	`else {`
254	`if (! equalr(r, obj->rect))`	259	`if (! equalr(r, obj->rect))`
255	`MoveWindow(obj->handle, r.x, r.y, r.width, r.height, 1);`	260	`MoveWindow(obj->handle, r.x, r.y, r.width, r.height, 1);`
256	`obj->rect.x = r.x;`	261	`obj->rect.x = r.x;`
257	`obj->rect.y = r.y;`	262	`obj->rect.y = r.y;`
258	`}`	263	`}`
259	`obj->rect.width = r.width;`	264	`obj->rect.width = r.width;`
260	`obj->rect.height = r.height;`	265	`obj->rect.height = r.height;`
261	`}`	266	`}`
262		267
263	`/*`	268	`/*`
264	`* Showing and hiding controls and windows.`	269	`* Showing and hiding controls and windows.`
265	`*/`	270	`*/`
266	`void show(control obj)`	271	`void show(control obj)`
267	`{`	272	`{`
268	`if (! obj)`	273	`if (! obj)`
269	`return;`	274	`return;`
270	`switch (obj->kind)`	275	`switch (obj->kind)`
271	`{`	276	`{`
272	`case CursorObject: case FontObject: case BitmapObject:`	277	`case CursorObject: case FontObject: case BitmapObject:`
273	`case MenubarObject: case MenuObject: case MenuitemObject:`	278	`case MenubarObject: case MenuObject: case MenuitemObject:`
274	`break;`	279	`break;`
275	`case WindowObject:`	280	`case WindowObject:`
276	`obj->state \|= Visible;`	281	`obj->state \|= Visible;`
277	`show_window(obj);`	282	`show_window(obj);`
278	`break;`	283	`break;`
279	`default:`	284	`default:`
280	`ShowWindow(obj->handle, SW_SHOWNORMAL);`	285	`ShowWindow(obj->handle, SW_SHOWNORMAL);`
281	`SetFocus(obj->handle);`	286	`SetFocus(obj->handle);`
282	`UpdateWindow(obj->handle);`	287	`UpdateWindow(obj->handle);`
283	`}`	288	`}`
284	`obj->state \|= Visible;`	289	`obj->state \|= Visible;`
285	`}`	290	`}`
286		291
287	`void hide(control obj)`	292	`void hide(control obj)`
288	`{`	293	`{`
289	`if (! obj)`	294	`if (! obj)`
290	`return;`	295	`return;`
291	`switch (obj->kind)`	296	`switch (obj->kind)`
292	`{`	297	`{`
293	`case CursorObject: case FontObject: case BitmapObject:`	298	`case CursorObject: case FontObject: case BitmapObject:`
294	`case MenubarObject: case MenuObject: case MenuitemObject:`	299	`case MenubarObject: case MenuObject: case MenuitemObject:`
295	`break;`	300	`break;`
296	`case WindowObject:`	301	`case WindowObject:`
297	`hide_window(obj);`	302	`hide_window(obj);`
298	`break;`	303	`break;`
299	`default:`	304	`default:`
300	`ShowWindow(obj->handle, SW_HIDE);`	305	`ShowWindow(obj->handle, SW_HIDE);`
301	`}`	306	`}`
302	`obj->state &= ~Visible;`	307	`obj->state &= ~Visible;`
303	`}`	308	`}`
304		309
305	`int isvisible(control obj)`	310	`int isvisible(control obj)`
306	`{`	311	`{`
307	`if (! obj)`	312	`if (! obj)`
308	`return 0;`	313	`return 0;`
309	`return (obj->state & Visible) ? 1 : 0;`	314	`return (obj->state & Visible) ? 1 : 0;`
310	`}`	315	`}`
311		316
312	`/*`	317	`/*`
313	`* Enabling and disabling controls and windows.`	318	`* Enabling and disabling controls and windows.`
314	`*/`	319	`*/`
315	`void enable(control obj)`	320	`void enable(control obj)`
316	`{`	321	`{`
317	`if (! obj)`	322	`if (! obj)`
318	`return;`	323	`return;`
319	`switch (obj->kind)`	324	`switch (obj->kind)`
320	`{`	325	`{`
321	`case CursorObject: case FontObject: case BitmapObject:`	326	`case CursorObject: case FontObject: case BitmapObject:`
322	`case MenubarObject:`	327	`case MenubarObject:`
323	`break;`	328	`break;`
324	`case MenuObject: case MenuitemObject:`	329	`case MenuObject: case MenuitemObject:`
325	`EnableMenuItem(obj->parent->handle,`	330	`EnableMenuItem(obj->parent->handle,`
326	`obj->id, MF_ENABLED \| MF_BYCOMMAND);`	331	`obj->id, MF_ENABLED \| MF_BYCOMMAND);`
327	`break;`	332	`break;`
328	`case FieldObject: case TextboxObject:`	333	`case FieldObject: case TextboxObject:`
329	`sendmessage(obj->handle, EM_SETREADONLY, FALSE, 0L);`	334	`sendmessage(obj->handle, EM_SETREADONLY, FALSE, 0L);`
330	`break;`	335	`break;`
331	`default:`	336	`default:`
332	`if (! isenabled(obj)) {`	337	`if (! isenabled(obj)) {`
333	`EnableWindow(obj->handle, 1);`	338	`EnableWindow(obj->handle, 1);`
334	`obj->state \|= Enabled;`	339	`obj->state \|= Enabled;`
335	`draw(obj);`	340	`draw(obj);`
336	`}`	341	`}`
337	`}`	342	`}`
338	`obj->state \|= Enabled;`	343	`obj->state \|= Enabled;`
339	`}`	344	`}`
340		345
341	`void disable(control obj)`	346	`void disable(control obj)`
342	`{`	347	`{`
343	`if (! obj)`	348	`if (! obj)`
344	`return;`	349	`return;`
345	`switch (obj->kind)`	350	`switch (obj->kind)`
346	`{`	351	`{`
347	`case CursorObject: case FontObject: case BitmapObject:`	352	`case CursorObject: case FontObject: case BitmapObject:`
348	`case MenubarObject: case MenuObject:`	353	`case MenubarObject: case MenuObject:`
349	`break;`	354	`break;`
350	`case MenuitemObject:`	355	`case MenuitemObject:`
351	`EnableMenuItem(obj->parent->handle,`	356	`EnableMenuItem(obj->parent->handle,`
352	`obj->id, MF_GRAYED \| MF_BYCOMMAND);`	357	`obj->id, MF_GRAYED \| MF_BYCOMMAND);`
353	`break;`	358	`break;`
354	`case FieldObject: case TextboxObject:`	359	`case FieldObject: case TextboxObject:`
355	`sendmessage(obj->handle, EM_SETREADONLY, TRUE, 0L);`	360	`sendmessage(obj->handle, EM_SETREADONLY, TRUE, 0L);`
356	`break;`	361	`break;`
357	`default:`	362	`default:`
358	`if (isenabled(obj)) {`	363	`if (isenabled(obj)) {`
359	`EnableWindow(obj->handle, 0);`	364	`EnableWindow(obj->handle, 0);`
360	`obj->state &= ~Enabled;`	365	`obj->state &= ~Enabled;`
361	`draw(obj);`	366	`draw(obj);`
362	`}`	367	`}`
363	`}`	368	`}`
364	`obj->state &= ~Enabled;`	369	`obj->state &= ~Enabled;`
365	`}`	370	`}`
366		371
367	`int isenabled(control obj)`	372	`int isenabled(control obj)`
368	`{`	373	`{`
369	`if (! obj)`	374	`if (! obj)`
370	`return 0;`	375	`return 0;`
371	`return (obj->state & Enabled) ? 1 : 0;`	376	`return (obj->state & Enabled) ? 1 : 0;`
372	`}`	377	`}`
373		378
374	`/*`	379	`/*`
375	`* Checking and unchecking controls.`	380	`* Checking and unchecking controls.`
376	`*/`	381	`*/`
377	`void check(control obj)`	382	`void check(control obj)`
378	`{`	383	`{`
379	`if (! obj)`	384	`if (! obj)`
380	`return;`	385	`return;`
381	`switch (obj->kind)`	386	`switch (obj->kind)`
382	`{`	387	`{`
383	`case CursorObject: case FontObject: case BitmapObject:`	388	`case CursorObject: case FontObject: case BitmapObject:`
384	`case MenubarObject: case MenuObject:`	389	`case MenubarObject: case MenuObject:`
385	`break;`	390	`break;`
386	`case MenuitemObject:`	391	`case MenuitemObject:`
387	`CheckMenuItem(obj->parent->handle, obj->id,`	392	`CheckMenuItem(obj->parent->handle, obj->id,`
388	`MF_CHECKED \| MF_BYCOMMAND);`	393	`MF_CHECKED \| MF_BYCOMMAND);`
389	`break;`	394	`break;`
390	`#if USE_NATIVE_BUTTONS`	395	`#if USE_NATIVE_BUTTONS`
391	`case ButtonObject:`	396	`case ButtonObject:`
392	`sendmessage(obj->handle, BM_SETCHECK, 1, 0L);`	397	`sendmessage(obj->handle, BM_SETCHECK, 1, 0L);`
393	`break;`	398	`break;`
394	`#endif`	399	`#endif`
395	`#if USE_NATIVE_TOGGLES`	400	`#if USE_NATIVE_TOGGLES`
396	`case CheckboxObject: case RadioObject:`	401	`case CheckboxObject: case RadioObject:`
397	`sendmessage(obj->handle, BM_SETCHECK, 1, 0L);`	402	`sendmessage(obj->handle, BM_SETCHECK, 1, 0L);`
398	`break;`	403	`break;`
399	`#endif`	404	`#endif`
400	`default:`	405	`default:`
401	`if (! ischecked(obj)) {`	406	`if (! ischecked(obj)) {`
402	`obj->state \|= Checked;`	407	`obj->state \|= Checked;`
403	`draw(obj);`	408	`draw(obj);`
404	`}`	409	`}`
405	`}`	410	`}`
406	`obj->state \|= Checked;`	411	`obj->state \|= Checked;`
407	`}`	412	`}`
408		413
409	`void uncheck(control obj)`	414	`void uncheck(control obj)`
410	`{`	415	`{`
411	`if (! obj)`	416	`if (! obj)`
412	`return;`	417	`return;`
413	`switch (obj->kind)`	418	`switch (obj->kind)`
414	`{`	419	`{`
415	`case CursorObject: case FontObject: case BitmapObject:`	420	`case CursorObject: case FontObject: case BitmapObject:`
416	`case MenubarObject: case MenuObject:`	421	`case MenubarObject: case MenuObject:`
417	`break;`	422	`break;`
418	`case MenuitemObject:`	423	`case MenuitemObject:`
419	`CheckMenuItem(obj->parent->handle, obj->id,`	424	`CheckMenuItem(obj->parent->handle, obj->id,`
420	`MF_UNCHECKED \| MF_BYCOMMAND);`	425	`MF_UNCHECKED \| MF_BYCOMMAND);`
421	`break;`	426	`break;`
422	`#if USE_NATIVE_BUTTONS`	427	`#if USE_NATIVE_BUTTONS`
423	`case ButtonObject:`	428	`case ButtonObject:`
424	`sendmessage(obj->handle, BM_SETCHECK, 0, 0L);`	429	`sendmessage(obj->handle, BM_SETCHECK, 0, 0L);`
425	`break;`	430	`break;`
426	`#endif`	431	`#endif`
427	`#if USE_NATIVE_TOGGLES`	432	`#if USE_NATIVE_TOGGLES`
428	`case CheckboxObject: case RadioObject:`	433	`case CheckboxObject: case RadioObject:`
429	`sendmessage(obj->handle, BM_SETCHECK, 0, 0L);`	434	`sendmessage(obj->handle, BM_SETCHECK, 0, 0L);`
430	`break;`	435	`break;`
431	`#endif`	436	`#endif`
432	`default:`	437	`default:`
433	`if (ischecked(obj)) {`	438	`if (ischecked(obj)) {`
434	`obj->state &= ~Checked;`	439	`obj->state &= ~Checked;`
435	`draw(obj);`	440	`draw(obj);`
436	`}`	441	`}`
437	`}`	442	`}`
438	`obj->state &= ~Checked;`	443	`obj->state &= ~Checked;`
439	`}`	444	`}`
440		445
441	`int ischecked(control obj)`	446	`int ischecked(control obj)`
442	`{`	447	`{`
443	`if (! obj)`	448	`if (! obj)`
444	`return 0;`	449	`return 0;`
445	`return (obj->state & Checked) ? 1 : 0;`	450	`return (obj->state & Checked) ? 1 : 0;`
446	`}`	451	`}`
447		452
448	`/*`	453	`/*`
449	`* Highlighting and unhighlighting controls.`	454	`* Highlighting and unhighlighting controls.`
450	`*/`	455	`*/`
451	`void highlight(control obj)`	456	`void highlight(control obj)`
452	`{`	457	`{`
453	`if (! obj)`	458	`if (! obj)`
454	`return;`	459	`return;`
455	`switch (obj->kind)`	460	`switch (obj->kind)`
456	`{`	461	`{`
457	`case CursorObject: case FontObject: case BitmapObject:`	462	`case CursorObject: case FontObject: case BitmapObject:`
458	`case MenubarObject: case MenuObject: case MenuitemObject:`	463	`case MenubarObject: case MenuObject: case MenuitemObject:`
459	`break;`	464	`break;`
460	`#if USE_NATIVE_BUTTONS`	465	`#if USE_NATIVE_BUTTONS`
461	`case ButtonObject:`	466	`case ButtonObject:`
462	`sendmessage(obj->handle, BM_SETSTATE, 1, 0L);`	467	`sendmessage(obj->handle, BM_SETSTATE, 1, 0L);`
463	`break;`	468	`break;`
464	`#endif`	469	`#endif`
465	`#if USE_NATIVE_TOGGLES`	470	`#if USE_NATIVE_TOGGLES`
466	`case CheckboxObject: case RadioObject:`	471	`case CheckboxObject: case RadioObject:`
467	`sendmessage(obj->handle, BM_SETSTATE, 1, 0L);`	472	`sendmessage(obj->handle, BM_SETSTATE, 1, 0L);`
468	`break;`	473	`break;`
469	`#endif`	474	`#endif`
470	`case FieldObject: case TextboxObject:`	475	`case FieldObject: case TextboxObject:`
471	`sendmessage(obj->handle, EM_SETSEL, 0, MAKELONG(0,-1));`	476	`sendmessage(obj->handle, EM_SETSEL, 0, MAKELONG(0,-1));`
472	`break;`	477	`break;`
473	`default:`	478	`default:`
474	`if (! ishighlighted(obj)) {`	479	`if (! ishighlighted(obj)) {`
475	`obj->state \|= Highlighted;`	480	`obj->state \|= Highlighted;`
476	`draw(obj);`	481	`draw(obj);`
477	`}`	482	`}`
478	`}`	483	`}`
479	`obj->state \|= Highlighted;`	484	`obj->state \|= Highlighted;`
480	`}`	485	`}`
481		486
482	`void unhighlight(control obj)`	487	`void unhighlight(control obj)`
483	`{`	488	`{`
484	`if (! obj)`	489	`if (! obj)`
485	`return;`	490	`return;`
486	`switch (obj->kind)`	491	`switch (obj->kind)`
487	`{`	492	`{`
488	`case CursorObject: case FontObject: case BitmapObject:`	493	`case CursorObject: case FontObject: case BitmapObject:`
489	`case MenubarObject: case MenuObject: case MenuitemObject:`	494	`case MenubarObject: case MenuObject: case MenuitemObject:`
490	`break;`	495	`break;`
491	`#if USE_NATIVE_BUTTONS`	496	`#if USE_NATIVE_BUTTONS`
492	`case ButtonObject:`	497	`case ButtonObject:`
493	`sendmessage(obj->handle, BM_SETSTATE, 0, 0L);`	498	`sendmessage(obj->handle, BM_SETSTATE, 0, 0L);`
494	`break;`	499	`break;`
495	`#endif`	500	`#endif`

The R Project SVN R

(root)/trunk/src/gnuwin32/graphapp/controls.c @ 34412 – Rev 28991 → 31702