np2/macosx/toolwin.cpp - diff

Return to toolwin.cpp CVS log

Up to [RetroPC.NET] / np2 / macosx

Diff for /np2/macosx/toolwin.cpp between versions 1.10 and 1.19

version 1.10, 2003/11/12 19:06:33	version 1.19, 2004/03/15 05:06:01
Line 11	Line 11
#include "dialog.h"	#include "dialog.h"
#include "soundmng.h"	#include "soundmng.h"
#include "fdefine.h"	#include "fdefine.h"
	#include "mackbd.h"
	#include "mousemng.h"
	#include "pccore.h"
	#include "iocore.h"

	extern void HandleMenuChoice(long wParam);

enum {	enum {
IDC_TOOLHDDACC = 0,	IDC_TOOLHDDACC = 0,
Line 109 static const OSType subcommand[11] ={ '-	Line 114 static const OSType subcommand[11] ={ '-

#define BASENUMBER 4	#define BASENUMBER 4
static const ControlID popup[2] = { {'pop1', 1}, {'pop2', 2} };	static const ControlID popup[2] = { {'pop1', 1}, {'pop2', 2} };
	static const ControlID imageid = {'back', 0};

static DragReceiveHandlerUPP dr;	static DragReceiveHandlerUPP dr;
static bool isPUMA;	static DragTrackingHandlerUPP tr;
	static bool isPUMA, isJaguar;

static void openpopup(HIPoint location);	static void openpopup(Point location);
static void skinchange(bool remake);	static void skinchange(bool remake);

// ----	// ----
Line 124 static void checkOSVersion(void) {	Line 131 static void checkOSVersion(void) {
Gestalt(gestaltSystemVersion, &res);	Gestalt(gestaltSystemVersion, &res);
if (res<0x1020) {	if (res<0x1020) {
isPUMA = true;	isPUMA = true;
	isJaguar = false;
}	}
	else if (res<0x1030) {
	isPUMA = false;
	isJaguar = true;
	}
else {	else {
isPUMA = false;	isPUMA = false;
	isJaguar = false;
}	}
}	}
}	}
Line 168 static PicHandle skinload(const char *pa	Line 181 static PicHandle skinload(const char *pa
return(ret);	return(ret);
}	}
}	}
return(getBMPfromResource("np2tool", bounds, CFSTR("bmp")));	return(getBMPfromResource("np2tool.bmp", bounds));
}	}

// ----	// ----
Line 177 static void setlist(ControlRef hwnd, con	Line 190 static void setlist(ControlRef hwnd, con
#if 0	#if 0
Rect rc;	Rect rc;
int width;	int width;
#endif
char basedir[MAX_PATH];
UINT i;
const char *p;
char dir[MAX_PATH];	char dir[MAX_PATH];
const char *q;	char basedir[MAX_PATH];
char cfname[512];	#endif
MenuHandle menu;	MenuHandle menu;
	UINT i;
	char cfname[512];
	const char *q;
	const char *p;
	CFStringRef str;
	Str255 pname;
	bool success = false;

GetBevelButtonMenuHandle(hwnd, &menu);	GetBevelButtonMenuHandle(hwnd, &menu);
while (MenuHasEnabledItems(menu)) {	DeleteMenuItems(menu, 1, fdd->cnt);
DeleteMenuItem(menu, 1);
};
#if 0	#if 0
GetControlBounds(hwnd, &rc);	GetControlBounds(hwnd, &rc);
width = rc.right - rc.left - 6; // border size?	width = rc.right - rc.left - 6; // border size?
#endif
basedir[0] = '\0';	basedir[0] = '\0';
if (sel < fdd->cnt) {	if (sel < fdd->cnt) {
milstr_ncpy(basedir, fdd->name[fdd->pos[sel]], sizeof(basedir));	milstr_ncpy(basedir, fdd->name[fdd->pos[sel]], sizeof(basedir));
file_cutname(basedir);	file_cutname(basedir);
}	}
	#endif
for (i=0; i<fdd->cnt; i++) {	for (i=0; i<fdd->cnt; i++) {
	SInt32 attr = kMenuItemAttrIconDisabled;
p = fdd->name[fdd->pos[i]];	p = fdd->name[fdd->pos[i]];
if (getLongFileName(cfname, p)) {	success = getLongFileName(cfname, p);
q = cfname;	str = CFStringCreateWithCString(NULL, cfname, CFStringGetSystemEncoding());
	if (str) {
	if (success) {
	if (file_attr(p) != FILEATTR_ARCHIVE) {
	attr \|= kMenuItemAttrDisabled;
	}
	AppendMenuItemTextWithCFString(menu, str, attr, NULL, NULL);
	}
	CFRelease(str);
}	}
else {	else {
	#if 0
milstr_ncpy(dir, p, sizeof(dir));	milstr_ncpy(dir, p, sizeof(dir));
file_cutname(dir);	file_cutname(dir);
#if 0
if (!file_cmpname(basedir, dir)) {	if (!file_cmpname(basedir, dir)) {
q = file_getname((char *)p);	q = file_getname((char *)p);
}	}
Line 216 const char *q;	Line 239 const char *q;
q = dir;	q = dir;
}	}
#else	#else
q = file_getname((char *)p);	q = file_getname((char *)p);
#endif	#endif
}	mkstr255(pname, q);
AppendMenu(menu, "\pNot Available");	AppendMenu(menu, pname);
SetMenuItemTextWithCFString(menu, i+1, CFStringCreateWithCString(NULL,q,kCFStringEncodingUTF8));	if (file_attr(p)==FILEATTR_ARCHIVE) {
if (file_attr(p)==FILEATTR_ARCHIVE) {	EnableMenuItem(menu, i+1);
EnableMenuItem(menu, i+1);	}
	else {
	DisableMenuItem(menu, i+1);
	}
}	}
p += sizeof(fdd->name[0]);	p += sizeof(fdd->name[0]);
}	}
Line 230 const char *q;	Line 256 const char *q;
CFStringRef title;	CFStringRef title;
SetBevelButtonMenuValue(hwnd, sel+1);	SetBevelButtonMenuValue(hwnd, sel+1);
CopyMenuItemTextAsCFString(menu, sel+1, &title);	CopyMenuItemTextAsCFString(menu, sel+1, &title);
SetControlTitleWithCFString(hwnd, title);	if (title) {
	SetControlTitleWithCFString(hwnd, title);
	CFRelease(title);
	}
}	}
else {	else {
SetControlTitleWithCFString(hwnd, CFSTR(" "));	SetControlTitleWithCFString(hwnd, CFSTR(" "));
	for (i=0; i<fdd->cnt; i++) {
	CheckMenuItem(menu, i+1, 0);
	}
}	}
}	}

Line 332 static pascal OSStatus cfControlproc(Eve	Line 364 static pascal OSStatus cfControlproc(Eve
}	}
else if (GetEventClass(event)==kEventClassControl && GetEventKind(event)==kEventControlContextualMenuClick) {	else if (GetEventClass(event)==kEventClassControl && GetEventKind(event)==kEventControlContextualMenuClick) {
HIPoint location;	HIPoint location;
	Point point;

soundmng_stop();	soundmng_stop();
GetEventParameter (event, kEventParamMouseLocation, typeHIPoint, NULL, sizeof(HIPoint), NULL, &location);	GetEventParameter (event, kEventParamMouseLocation, typeHIPoint, NULL, sizeof(HIPoint), NULL, &location);
openpopup(location);	point.h = (short)location.x;
	point.v = (short)location.y;
	if (!isJaguar && !isPUMA) {
	GrafPtr port, dst;
	bool portchanged;
	dst = GetWindowPort(toolwin.hwnd);
	portchanged = QDSwapPort(dst, &port);
	LocalToGlobal(&point);
	if (portchanged) QDSwapPort(port, NULL);
	}
	openpopup(point);
soundmng_play();	soundmng_play();
}	}

Line 343 static pascal OSStatus cfControlproc(Eve	Line 387 static pascal OSStatus cfControlproc(Eve
return err;	return err;
}	}

	static PixPatHandle portpat;

	static void setDragColor(GrafPtr window) {
	GrafPtr port;
	RGBColor color;
	bool portchanged;

	portchanged = QDSwapPort(window, &port);
	GetThemeBrushAsColor(kThemeBrushDragHilite, 32, true, &color);
	portpat = NewPixPat();
	MakeRGBPat(portpat, &color);
	PenPixPat(portpat);
	PenSize(3, 3);
	if (portchanged) QDSwapPort(port, NULL);
	}

static void toolwincreate(WindowRef hWnd) {	static void toolwincreate(WindowRef hWnd) {

const SUBITEM *p;	const SUBITEM *p;
Line 351 const SUBITEM *p;	Line 411 const SUBITEM *p;
const char *cls;	const char *cls;
UInt32 style;	UInt32 style;

	setDragColor(GetWindowPort(hWnd));

ControlButtonContentInfo info;	ControlButtonContentInfo info;
info.contentType = kControlContentPictHandle;	info.contentType = kControlContentPictHandle;
info.u.picture = NULL;	info.u.picture = NULL;
Line 450 static void toolwindestroy(void) {	Line 512 static void toolwindestroy(void) {
DisposePixPat(toolwin.access[1]);	DisposePixPat(toolwin.access[1]);
KillPicture(toolwin.hbmp);	KillPicture(toolwin.hbmp);
toolwin.hbmp = NULL;	toolwin.hbmp = NULL;
	DisposePixPat(portpat);
}	}
}	}

Line 467 static pascal OSStatus cfWinproc(EventHa	Line 530 static pascal OSStatus cfWinproc(EventHa
switch (cmd.commandID)	switch (cmd.commandID)
{	{
case 'rset':	case 'rset':
recieveCommand(IDM_RESET);	HandleMenuChoice(IDM_RESET);
err=noErr;	err=noErr;
break;	break;

Line 477 static pascal OSStatus cfWinproc(EventHa	Line 540 static pascal OSStatus cfWinproc(EventHa
break;	break;

case 'opn1':	case 'opn1':
recieveCommand(IDM_FDD1OPEN);	HandleMenuChoice(IDM_FDD1OPEN);
err=noErr;	err=noErr;
break;	break;

case 'ejt1':	case 'ejt1':
recieveCommand(IDM_FDD1EJECT);	HandleMenuChoice(IDM_FDD1EJECT);
err=noErr;	err=noErr;
break;	break;

Line 492 static pascal OSStatus cfWinproc(EventHa	Line 555 static pascal OSStatus cfWinproc(EventHa
break;	break;

case 'opn2':	case 'opn2':
recieveCommand(IDM_FDD2OPEN);	HandleMenuChoice(IDM_FDD2OPEN);
err=noErr;	err=noErr;
break;	break;

case 'ejt2':	case 'ejt2':
recieveCommand(IDM_FDD2EJECT);	HandleMenuChoice(IDM_FDD2EJECT);
err=noErr;	err=noErr;
break;	break;

case 'exit':	case 'exit':
recieveCommand(IDM_EXIT);	HandleMenuChoice(IDM_EXIT);
err=noErr;	err=noErr;
break;	break;

Line 513 static pascal OSStatus cfWinproc(EventHa	Line 576 static pascal OSStatus cfWinproc(EventHa
else if (GetEventClass(event)==kEventClassWindow) {	else if (GetEventClass(event)==kEventClassWindow) {
switch (GetEventKind(event)) {	switch (GetEventKind(event)) {
case kEventWindowClose:	case kEventWindowClose:
	#ifdef AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
	case kEventWindowDrawerClosed:
	#endif
toolwin_close();	toolwin_close();
err=noErr;	err=noErr;
break;	break;
Line 525 static pascal OSStatus cfWinproc(EventHa	Line 591 static pascal OSStatus cfWinproc(EventHa
Draw1Control(sub);	Draw1Control(sub);
}	}
}	}
	err=noErr;
break;	break;

case kEventWindowFocusAcquired:
SelectWindow(hWndMain);
break;


default:	default:
break;	break;
}	}
}	}
else if (GetEventClass(event)==kEventClassKeyboard && GetEventKind(event)==kEventRawKeyDown) {	else if (GetEventClass(event)==kEventClassKeyboard) {
UInt32 modif;	UInt32 whatHappened = GetEventKind(event);
	UInt32 key;
	GetEventParameter (event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &key);
	UInt32 modif;
GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modif);	GetEventParameter (event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modif);
if (modif & cmdKey) {	switch (whatHappened)
EventRecord eve;	{
ConvertEventRefToEventRecord( event,&eve );	case kEventRawKeyUp:
recieveCommand(MenuEvent(&eve));	mackbd_keyup(key);
	err = noErr;
	break;
	case kEventRawKeyRepeat:
	mackbd_keydown(key);
	err = noErr;
	break;
	case kEventRawKeyDown:
	if (modif & cmdKey) {
	EventRecord eve;
	ConvertEventRefToEventRecord( event,&eve );
	mousemng_disable(MOUSEPROC_MACUI);
	HandleMenuChoice(MenuEvent(&eve));
	mousemng_enable(MOUSEPROC_MACUI);
	}
	else {
	mackbd_keydown(key);
	}
	err = noErr;
	break;
	default:
	break;
}	}
}	}

Line 550 static pascal OSStatus cfWinproc(EventHa	Line 636 static pascal OSStatus cfWinproc(EventHa
return err;	return err;
}	}

OSErr setDropFile(FSSpec spec, int drv) {	static int getTypeFromFSSpec(char* fname, FSSpec* spec) {
char fname[MAX_PATH];
int ftype;	int ftype;

fsspec2path(&spec, fname, MAX_PATH);	fsspec2path(spec, fname, MAX_PATH);
ftype = file_getftype(fname);	ftype = file_getftype(fname);
switch (ftype) {
	return (ftype);
	}

	OSErr setDropFile(FSSpec spec, int drv) {
	char fname[MAX_PATH];

	switch (getTypeFromFSSpec(fname, &spec)) {
case FTYPE_D88:	case FTYPE_D88:
case FTYPE_BETA:	case FTYPE_BETA:
if (drv == -1) {	if (drv == -1) {
Line 566 OSErr setDropFile(FSSpec spec, int drv)	Line 658 OSErr setDropFile(FSSpec spec, int drv)
toolwin_setfdd(drv, fname);	toolwin_setfdd(drv, fname);
break;	break;

case FTYPE_TEXT:	case FTYPE_INI:
strcpy(np2tool.skin, fname);	strcpy(np2tool.skin, fname);
skinchange(true);	skinchange(true);
break;	break;
Line 582 OSErr setDropFile(FSSpec spec, int drv)	Line 674 OSErr setDropFile(FSSpec spec, int drv)
return(noErr);	return(noErr);
}	}

static pascal OSErr DragReceiver( WindowRef theWindow, void *handlerRefCon, DragRef theDrag )	static OSErr getFSSpecFromDragItem(DragRef theDrag, HFSFlavor* aHFSFlavor) {
{	UInt16 numItems;
	DragItemRef ItemRef;
	FlavorType Type;

	CountDragItems( theDrag, &numItems );
	if ( numItems != 1 ) {
	return( -1 );
	}
	GetDragItemReferenceNumber( theDrag, 1, &ItemRef );
	GetFlavorType( theDrag, ItemRef, 1, &Type );
	if ( Type != flavorTypeHFS ) {
	return( -1 );
	}
	Size dataSize = sizeof(HFSFlavor);
	GetFlavorData( theDrag, ItemRef, flavorTypeHFS, aHFSFlavor, &dataSize, 0 );
	return(noErr);
	}

	static SInt16 whichControl(DragRef theDrag, WindowRef theWindow) {
SInt16 drv = -1;	SInt16 drv = -1;
Point pt;	Point pt;
	int i;
ControlRef popupref[2];	ControlRef popupref[2];
Rect bounds[2];	Rect bounds[2];
int i;

GetDragMouse(theDrag, &pt, NULL);	GetDragMouse(theDrag, &pt, NULL);
GlobalToLocal(&pt);	GlobalToLocal(&pt);
Line 600 static pascal OSErr DragReceiver( Window	Line 710 static pascal OSErr DragReceiver( Window
break;	break;
}	}
}	}
	return(drv);
	}

UInt16 numItems;	static OSErr DragTracker (DragTrackingMessage message, WindowRef theWindow, void * handlerRefCon, DragRef theDrag) {
CountDragItems( theDrag, &numItems );	SInt16 drv = -1;
if ( numItems != 1 )	HFSFlavor aHFSFlavor;
{	RgnHandle rgn = NULL;
return( -1 );	char fname[MAX_PATH];
	ControlRef targetControl;
	GrafPtr port;
	bool portchanged = false;
	static bool hilite = false;
	Rect bounds;
	ControlRef back;

	if (message == kDragTrackingEnterHandler \|\| message == kDragTrackingLeaveHandler) {
	hilite = false;
	return (noErr);
	}
	if (getFSSpecFromDragItem(theDrag, &aHFSFlavor) != noErr) {
	if (hilite) {
	GetControlByID(theWindow, &imageid, &back);
	Draw1Control(back);
	hilite = false;
	}
	return (-1);
	}
	if (message != kDragTrackingLeaveWindow) {
	switch (getTypeFromFSSpec(fname, &aHFSFlavor.fileSpec)) {
	case FTYPE_D88:
	case FTYPE_BETA:
	drv = whichControl(theDrag, theWindow);
	if (drv == -1) {
	message = kDragTrackingLeaveWindow;
	}
	else {
	GetControlByID(theWindow, &popup[drv], &targetControl);
	GetControlBounds(targetControl, &bounds);
	}
	break;

	case FTYPE_INI:
	case FTYPE_THD:
	case FTYPE_HDI:
	GetWindowBounds(theWindow, kWindowContentRgn, &bounds);
	OffsetRect(&bounds, -bounds.left, -bounds.top);
	break;

	default:
	return(noErr);
	}
}	}

DragItemRef ItemRef;
GetDragItemReferenceNumber( theDrag, 1, &ItemRef );

FlavorType Type;	portchanged = QDSwapPort(GetWindowPort(theWindow), &port);
GetFlavorType( theDrag, ItemRef, 1, &Type );	if (message == kDragTrackingLeaveWindow && hilite) {
if ( Type != flavorTypeHFS )	GetControlByID(theWindow, &imageid, &back);
{	Draw1Control(back);
return( -1 );	hilite = false;
	}
	else {
	rgn = NewRgn();
	if (rgn) {
	RectRgn(rgn, &bounds);
	FrameRgn(rgn);
	DisposeRgn(rgn);
	}
	hilite = true;
}	}
	if (portchanged) QDSwapPort(port, NULL);

	return(noErr);
	}

	static pascal OSErr DragReceiver( WindowRef theWindow, void *handlerRefCon, DragRef theDrag )
	{
	SInt16 drv = -1;
HFSFlavor aHFSFlavor;	HFSFlavor aHFSFlavor;
Size dataSize = sizeof(aHFSFlavor);	ControlRef back;
GetFlavorData( theDrag, ItemRef, flavorTypeHFS, &aHFSFlavor, &dataSize, 0 );
	GetControlByID(theWindow, &imageid, &back);
	Draw1Control(back);

	if (getFSSpecFromDragItem(theDrag, &aHFSFlavor) != noErr) {
	return (-1);
	}
	drv = whichControl(theDrag, theWindow);
return( setDropFile(aHFSFlavor.fileSpec, drv) );	return( setDropFile(aHFSFlavor.fileSpec, drv) );
}	}

Line 644 static WindowRef makeNibWindow (IBNibRef	Line 818 static WindowRef makeNibWindow (IBNibRef
{ kEventClassWindow, kEventWindowClose },	{ kEventClassWindow, kEventWindowClose },
{ kEventClassWindow, kEventWindowShown },	{ kEventClassWindow, kEventWindowShown },
{ kEventClassWindow, kEventWindowDrawContent },	{ kEventClassWindow, kEventWindowDrawContent },
{ kEventClassWindow, kEventWindowFocusAcquired },	{ kEventClassKeyboard, kEventRawKeyUp},
{ kEventClassKeyboard, kEventRawKeyDown},	{ kEventClassKeyboard, kEventRawKeyDown},
	{ kEventClassKeyboard, kEventRawKeyRepeat},
	#ifdef AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
	{ kEventClassWindow, kEventWindowDrawerClosed },
	#endif
};	};
EventHandlerRef ref;	EventHandlerRef ref;
InstallWindowEventHandler (win, NewEventHandlerUPP(cfWinproc), GetEventTypeCount(list), list, (void *)win, &ref);	InstallWindowEventHandler (win, NewEventHandlerUPP(cfWinproc), GetEventTypeCount(list), list, (void *)win, &ref);

dr = NewDragReceiveHandlerUPP((DragReceiveHandlerProcPtr)DragReceiver);	dr = NewDragReceiveHandlerUPP((DragReceiveHandlerProcPtr)DragReceiver);
	tr = NewDragTrackingHandlerUPP((DragTrackingHandlerProcPtr)DragTracker);
InstallReceiveHandler( dr, win, NULL);	InstallReceiveHandler( dr, win, NULL);
	InstallTrackingHandler( tr, win, NULL);
}	}
return(win);	return(win);
}	}
Line 735 const char *p;	Line 915 const char *p;


// ----	// ----
static void openpopup(HIPoint location) {	static void openpopup(Point location) {

MenuRef hMenu;	MenuRef hMenu;
short sel;	short sel;
Line 749 static void openpopup(HIPoint location)	Line 929 static void openpopup(HIPoint location)
AppendMenuItemTextWithCFString(hMenu, CFCopyLocalizedString(CFSTR("Close"),"ToolWin Close"), kMenuItemAttrIconDisabled, NULL, NULL);	AppendMenuItemTextWithCFString(hMenu, CFCopyLocalizedString(CFSTR("Close"),"ToolWin Close"), kMenuItemAttrIconDisabled, NULL, NULL);
DeleteMenu(222);	DeleteMenu(222);
selectclose = CountMenuItems(hMenu);	selectclose = CountMenuItems(hMenu);
sel = LoWord(PopUpMenuSelect(hMenu, (short)location.y, (short)location.x, 0));	sel = LoWord(PopUpMenuSelect(hMenu, location.v, location.h, 0));
DisposeMenu(hMenu);	DisposeMenu(hMenu);
if (sel == selectclose) {	if (sel == selectclose) {
toolwin_close();	toolwin_close();
Line 757 static void openpopup(HIPoint location)	Line 937 static void openpopup(HIPoint location)
else {	else {
switch (sel) {	switch (sel) {
case 1:	case 1:
if(dialog_fileselect(fname, sizeof(fname), hWndMain)) {	if(dialog_fileselect(fname, sizeof(fname), hWndMain, OPEN_INI)) {
if (file_getftype(fname)==FTYPE_TEXT) {	if (file_getftype(fname)==FTYPE_INI) {
strcpy(np2tool.skin, fname);	strcpy(np2tool.skin, fname);
skinchange(true);	skinchange(true);
}	}
Line 786 static void openpopup(HIPoint location)	Line 966 static void openpopup(HIPoint location)

}	}

	static void makeskinimage(WindowRef win,PicHandle bmp, Rect* rect) {
	ControlButtonContentInfo info;
	ControlRef image;
	EventHandlerRef ref;
	EventTypeSpec list[]={
	{ kEventClassControl, kEventControlContextualMenuClick },
	};

	info.contentType = kControlContentPictHandle;
	info.u.picture = bmp;
	CreatePictureControl(win, rect, &info, true, &image);
	SetControlID(image, &imageid);
	InstallControlEventHandler (image, NewEventHandlerUPP(cfControlproc), GetEventTypeCount(list), list, (void *)win, &ref);
	}

	static void opentoolwin_puma(WindowRef win) {
	if (np2tool.posy < 35) np2tool.posy = 35;
	if (np2tool.posx < 5 ) np2tool.posx = 5;
	MoveWindow(win, np2tool.posx, np2tool.posy, true);
	ShowWindow(win);
	}

void toolwin_open(void) {	void toolwin_open(void) {

PicHandle hbmp;	PicHandle hbmp;
WindowRef hWnd = NULL;	WindowRef hWnd = NULL;
Rect bounds;	Rect bounds;
ControlRef image;
EventTypeSpec list[]={
{ kEventClassControl, kEventControlContextualMenuClick },
};
EventHandlerRef ref;

if (toolwin.hwnd) {	if (toolwin.hwnd) {
toolwin_close();	toolwin_close();
Line 816 void toolwin_open(void) {	Line 1013 void toolwin_open(void) {
goto twope_err2;	goto twope_err2;
}	}

if (isPUMA) {
	SetWindowBounds(hWnd, kWindowContentRgn, &bounds);
	if (isPUMA) {
toolwincreate(hWnd);	toolwincreate(hWnd);
	makeskinimage(hWnd, hbmp, &bounds);
}	}
SizeWindow(hWnd, bounds.right-bounds.left, bounds.bottom-bounds.top, true);	else {
ControlButtonContentInfo info;	makeskinimage(hWnd, hbmp, &bounds);
info.contentType = kControlContentPictHandle;
info.u.picture = hbmp;
CreatePictureControl(hWnd, &bounds, &info, true, &image);
InstallControlEventHandler (image, NewEventHandlerUPP(cfControlproc), GetEventTypeCount(list), list, (void *)hWnd, &ref);
if (!isPUMA) {
toolwincreate(hWnd);	toolwincreate(hWnd);
}	}
#ifndef AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER	#ifndef AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
if (np2tool.posy < 35) np2tool.posy = 35;	opentoolwin_puma(hWnd);
if (np2tool.posx < 5 ) np2tool.posx = 5;
MoveWindow(hWnd, np2tool.posx, np2tool.posy, true);
ShowWindow(hWnd);
#else	#else
if (isPUMA) {	if (isPUMA) {
if (np2tool.posy < 35) np2tool.posy = 35;	opentoolwin_puma(hWnd);
if (np2tool.posx < 5 ) np2tool.posx = 5;
MoveWindow(hWnd, np2tool.posx, np2tool.posy, true);
ShowWindow(hWnd);
}	}
else {	else {
Rect mainbounds;	Rect mainbounds;
Line 852 void toolwin_open(void) {	Line 1041 void toolwin_open(void) {
}	}
SetDrawerOffsets(hWnd, width/2-11, width/2-11);	SetDrawerOffsets(hWnd, width/2-11, width/2-11);
SetDrawerPreferredEdge(hWnd, kWindowEdgeTop);	SetDrawerPreferredEdge(hWnd, kWindowEdgeTop);
	const HISize size = {bounds.right-bounds.left, bounds.bottom-bounds.top};
	SetWindowResizeLimits(hWnd, &size, &size);
OpenDrawer(hWnd, kWindowEdgeDefault, 1);	OpenDrawer(hWnd, kWindowEdgeDefault, 1);
}	}
#endif	#endif
Line 881 void toolwin_close(void) {	Line 1072 void toolwin_close(void) {
}	}
#endif	#endif
RemoveReceiveHandler(dr, toolwin.hwnd);	RemoveReceiveHandler(dr, toolwin.hwnd);
	RemoveTrackingHandler(tr, toolwin.hwnd);
toolwindestroy();	toolwindestroy();
DisposeWindow(toolwin.hwnd);	DisposeWindow(toolwin.hwnd);
toolwin.hwnd = NULL;	toolwin.hwnd = NULL;

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.10
changed lines
	Added in v.1.19