--- np2/macosx/toolwin.cpp	2003/11/03 17:36:24	1.2
+++ np2/macosx/toolwin.cpp	2004/03/15 05:06:01	1.19
@@ -11,6 +11,12 @@
 #include	"dialog.h"
 #include	"soundmng.h"
 #include	"fdefine.h"
+#include	"mackbd.h"
+#include	"mousemng.h"
+#include	"pccore.h"
+#include	"iocore.h"
+
+extern void HandleMenuChoice(long wParam);
 
 enum {
 	IDC_TOOLHDDACC			= 0,
@@ -106,14 +112,39 @@ static const OSType subcommand[11] ={	'-
                                         'exit',
                                     };
 
+#define	BASENUMBER	4
 static const ControlID popup[2] = { {'pop1', 1}, {'pop2', 2} };
+static const ControlID imageid = {'back', 0};
 
-static void openpopup(HIPoint location);
-static void skinchange(void);
 static DragReceiveHandlerUPP	dr;
+static DragTrackingHandlerUPP	tr;
+static bool	isPUMA, isJaguar;
+
+static void openpopup(Point location);
+static void skinchange(bool remake);
 
 // ----
 
+static void checkOSVersion(void) {
+    static	long	res = 0;
+    if (!res) {
+        Gestalt(gestaltSystemVersion, &res);
+        if (res<0x1020) {
+            isPUMA = true;
+			isJaguar = false;
+        }
+		else if (res<0x1030) {
+            isPUMA = false;
+			isJaguar = true;
+		}
+        else {
+            isPUMA = false;
+			isJaguar = false;
+        }
+    }
+}
+
+
 static PicHandle skinload(const char *path, Rect* bounds) {
 
 	char		fname[MAX_PATH];
@@ -150,7 +181,7 @@ static PicHandle skinload(const char *pa
 			return(ret);
 		}
 	}
-	return(getBMPfromResource("np2tool", bounds));
+	return(getBMPfromResource("np2tool.bmp", bounds));
 }
 
 // ----
@@ -159,37 +190,47 @@ static void setlist(ControlRef hwnd, con
 #if 0
 	Rect	rc;
 	int		width;
-#endif
-	char	basedir[MAX_PATH];
-	UINT	i;
-const char	*p;
 	char	dir[MAX_PATH];
-const char	*q;
-    char	cfname[512];
+	char		basedir[MAX_PATH];
+#endif
     MenuHandle	menu;
+	UINT		i;
+    char		cfname[512];
+const char		*q;
+const char		*p;
+    CFStringRef	str;
+    Str255		pname;
+    bool		success = false;
     
     GetBevelButtonMenuHandle(hwnd, &menu);
-    while (MenuHasEnabledItems(menu)) {
-        DeleteMenuItem(menu, 1);
-    };
+	DeleteMenuItems(menu, 1, fdd->cnt);
 #if 0
 	GetControlBounds(hwnd, &rc);
 	width = rc.right - rc.left - 6;			// border size?
-#endif
 	basedir[0] = '\0';
 	if (sel < fdd->cnt) {
 		milstr_ncpy(basedir, fdd->name[fdd->pos[sel]], sizeof(basedir));
 		file_cutname(basedir);
 	}
+#endif
 	for (i=0; i<fdd->cnt; i++) {
+        SInt32		attr = kMenuItemAttrIconDisabled;
 		p = fdd->name[fdd->pos[i]];
-        if (getLongFileName(cfname, p)) {
-            q = cfname;
+        success = getLongFileName(cfname, p);
+        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 {
+#if 0
             milstr_ncpy(dir, p, sizeof(dir));
             file_cutname(dir);
-#if 0
             if (!file_cmpname(basedir, dir)) {
                 q = file_getname((char *)p);
             }
@@ -198,13 +239,16 @@ const char	*q;
             	q = dir;
             }
 #else
-                q = file_getname((char *)p);
+            q = file_getname((char *)p);
 #endif
-        }
-        AppendMenu(menu, "\pNot Available");
-        SetMenuItemTextWithCFString(menu, i+1, CFStringCreateWithCString(NULL,q,kCFStringEncodingUTF8));
-        if (file_attr(p)==FILEATTR_ARCHIVE) {
-            EnableMenuItem(menu, i+1);
+            mkstr255(pname, q);
+            AppendMenu(menu, pname);
+            if (file_attr(p)==FILEATTR_ARCHIVE) {
+                EnableMenuItem(menu, i+1);
+            }
+            else {
+                DisableMenuItem(menu, i+1);
+            }
         }
 		p += sizeof(fdd->name[0]);
 	}
@@ -212,10 +256,16 @@ const char	*q;
         CFStringRef title;
         SetBevelButtonMenuValue(hwnd, sel+1);
         CopyMenuItemTextAsCFString(menu, sel+1, &title);
-        SetControlTitleWithCFString(hwnd, title);
+		if (title) {
+			SetControlTitleWithCFString(hwnd, title);
+			CFRelease(title);
+		}
     }
     else {
         SetControlTitleWithCFString(hwnd, CFSTR(" "));
+		for (i=0; i<fdd->cnt; i++) {
+			CheckMenuItem(menu, i+1, 0);
+		}
 	}
 }
 
@@ -314,9 +364,21 @@ static pascal OSStatus cfControlproc(Eve
     }
     else if (GetEventClass(event)==kEventClassControl && GetEventKind(event)==kEventControlContextualMenuClick) {
         HIPoint	location;
+		Point   point;
+    
         soundmng_stop();
         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();
     }
 
@@ -325,6 +387,22 @@ static pascal OSStatus cfControlproc(Eve
     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) {
 
 const SUBITEM	*p;
@@ -333,6 +411,8 @@ const SUBITEM	*p;
 const char		*cls;
 	UInt32		style;
     
+    setDragColor(GetWindowPort(hWnd));
+    
     ControlButtonContentInfo	info;
     info.contentType = kControlContentPictHandle;
     info.u.picture = NULL;
@@ -432,6 +512,7 @@ static void toolwindestroy(void) {
 		DisposePixPat(toolwin.access[1]);
         KillPicture(toolwin.hbmp);
         toolwin.hbmp = NULL;
+        DisposePixPat(portpat);
 	}
 }
 
@@ -441,13 +522,15 @@ static void toolwindestroy(void) {
 static pascal OSStatus cfWinproc(EventHandlerCallRef myHandler, EventRef event, void* userData) {
     OSStatus	err = eventNotHandledErr;
     HICommand	cmd;
+    ControlRef	sub;
+    int			i;
 
     if (GetEventClass(event)==kEventClassCommand && GetEventKind(event)==kEventCommandProcess ) {
         GetEventParameter(event, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &cmd);
         switch (cmd.commandID)
         {
             case 'rset':
-                recieveCommand(IDM_RESET);
+                HandleMenuChoice(IDM_RESET);
                 err=noErr;
                 break;
                 
@@ -457,12 +540,12 @@ static pascal OSStatus cfWinproc(EventHa
                 break;
                                 
             case 'opn1':
-                recieveCommand(IDM_FDD1OPEN);
+                HandleMenuChoice(IDM_FDD1OPEN);
                 err=noErr;
                 break;
                 
             case 'ejt1':
-                recieveCommand(IDM_FDD1EJECT);
+                HandleMenuChoice(IDM_FDD1EJECT);
                 err=noErr;
                 break;
                 
@@ -472,17 +555,17 @@ static pascal OSStatus cfWinproc(EventHa
                 break;
                                 
             case 'opn2':
-                recieveCommand(IDM_FDD2OPEN);
+                HandleMenuChoice(IDM_FDD2OPEN);
                 err=noErr;
                 break;
                 
             case 'ejt2':
-                recieveCommand(IDM_FDD2EJECT);
+                HandleMenuChoice(IDM_FDD2EJECT);
                 err=noErr;
                 break;
                 
             case 'exit':
-                recieveCommand(IDM_EXIT);
+                HandleMenuChoice(IDM_EXIT);
                 err=noErr;
                 break;
                 
@@ -493,26 +576,79 @@ static pascal OSStatus cfWinproc(EventHa
     else if (GetEventClass(event)==kEventClassWindow) {
         switch (GetEventKind(event)) {
             case kEventWindowClose:
+#ifdef AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+			case kEventWindowDrawerClosed:
+#endif
                 toolwin_close();
                 err=noErr;
                 break;
                 
+            case kEventWindowDrawContent:
+            case kEventWindowShown:
+                for (i=0; i<IDC_MAXITEMS; i++) {
+                    sub = toolwin.sub[i];
+                    if (sub) {
+                        Draw1Control(sub);
+                    }
+                }
+                err=noErr;
+                break;
+                
             default:
                 break;
         }
     }
+    else if (GetEventClass(event)==kEventClassKeyboard) {
+        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);
+        switch (whatHappened)
+        {
+            case kEventRawKeyUp:
+                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;             
+        }
+    }
 
 	(void)myHandler;
     return err;
 }
 
-OSErr setDropFile(FSSpec spec, int drv) {
-    char		fname[MAX_PATH];
+static int getTypeFromFSSpec(char* fname, FSSpec* spec) {
     int			ftype;
 
-    fsspec2path(&spec, fname, MAX_PATH);
+    fsspec2path(spec, fname, MAX_PATH);
     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_BETA:
             if (drv == -1) {
@@ -522,9 +658,9 @@ OSErr setDropFile(FSSpec spec, int drv) 
             toolwin_setfdd(drv, fname);
             break;
             
-        case FTYPE_TEXT:
+        case FTYPE_INI:
             strcpy(np2tool.skin, fname);
-            skinchange();
+            skinchange(true);
             break;
         
         case FTYPE_THD:
@@ -538,13 +674,31 @@ OSErr setDropFile(FSSpec spec, int drv) 
     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;
     Point		pt;
+    int			i;
     ControlRef	popupref[2];
     Rect		bounds[2];
-    int			i;
 
     GetDragMouse(theDrag, &pt, NULL);
     GlobalToLocal(&pt);
@@ -556,51 +710,128 @@ static pascal OSErr DragReceiver( Window
             break;
         }
     }
+    return(drv);
+}
 
-	UInt16 numItems;
-    CountDragItems( theDrag, &numItems );
-	if ( numItems != 1 )
-	{
-		return( -1 );
+static OSErr DragTracker (DragTrackingMessage message, WindowRef theWindow, void * handlerRefCon, DragRef theDrag) {
+    SInt16		drv = -1;
+	HFSFlavor	aHFSFlavor;
+    RgnHandle	rgn = NULL;
+    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;
-	GetFlavorType( theDrag, ItemRef, 1, &Type );
-	if ( Type != flavorTypeHFS )
-	{
-        return( -1 );
+    portchanged = QDSwapPort(GetWindowPort(theWindow), &port);
+    if (message == kDragTrackingLeaveWindow && hilite) {
+        GetControlByID(theWindow, &imageid, &back);
+        Draw1Control(back);
+        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;
-	Size dataSize = sizeof(aHFSFlavor);
-	GetFlavorData( theDrag, ItemRef, flavorTypeHFS, &aHFSFlavor, &dataSize, 0 );
-            
+    ControlRef	back;
+
+    GetControlByID(theWindow, &imageid, &back);
+    Draw1Control(back);
+
+    if (getFSSpecFromDragItem(theDrag, &aHFSFlavor) != noErr) {
+        return (-1);
+    }
+    drv = whichControl(theDrag, theWindow);
 	return( setDropFile(aHFSFlavor.fileSpec, drv) );
 }
 
 static WindowRef makeNibWindow (IBNibRef nibRef) {
     OSStatus	err;
     WindowRef	win = NULL;
-#if 0
-    Rect	bounds;
-    SetRect(&bounds, 0, 0, 100, 100);
-    err = CreateNewWindow(kOverlayWindowClass, kWindowStandardHandlerAttribute, &bounds, &win);
-#else
-    err = CreateWindowFromNib(nibRef, CFSTR("ToolWindow"), &win);
-#endif
+
+    if (isPUMA) {
+        Rect	bounds;
+        SetRect(&bounds, 0, 0, 100, 100);
+        err = CreateNewWindow(kFloatingWindowClass, kWindowStandardHandlerAttribute, &bounds, &win);
+    }
+    else {
+        err = CreateWindowFromNib(nibRef, CFSTR("ToolWindow"), &win);
+    }
     if (err == noErr) {
+        InstallStandardEventHandler(GetWindowEventTarget(win));
         EventTypeSpec	list[]={ 
-            { kEventClassCommand, kEventCommandProcess },
-            { kEventClassWindow, kEventWindowClose }, 
+            { kEventClassCommand, 	kEventCommandProcess },
+            { kEventClassWindow,	kEventWindowClose }, 
+            { kEventClassWindow,	kEventWindowShown }, 
+            { kEventClassWindow,	kEventWindowDrawContent }, 
+            { kEventClassKeyboard,	kEventRawKeyUp},
+            { kEventClassKeyboard,	kEventRawKeyDown},
+            { kEventClassKeyboard,	kEventRawKeyRepeat},
+#ifdef AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+			{ kEventClassWindow, 	kEventWindowDrawerClosed },
+#endif
         };
         EventHandlerRef	ref;
         InstallWindowEventHandler (win, NewEventHandlerUPP(cfWinproc), GetEventTypeCount(list), list, (void *)win, &ref);
 
         dr = NewDragReceiveHandlerUPP((DragReceiveHandlerProcPtr)DragReceiver);
+        tr = NewDragTrackingHandlerUPP((DragTrackingHandlerProcPtr)DragTracker);
         InstallReceiveHandler( dr, win, NULL);
+        InstallTrackingHandler( tr, win, NULL);
     }
     return(win);
 }
@@ -624,63 +855,48 @@ static void createskinmenu(MenuRef ret) 
 const char	*base;
 	char	*p;
 	UINT	i;
-	UINT	j;
-	UINT	id[SKINMRU_MAX];
-const char	*file[SKINMRU_MAX];
-    Str255	seltext, deftext;
+    char	longname[256];
 
-    mkstr255(seltext, str_skinsel);
-	AppendMenu(ret, seltext);
+	AppendMenuItemTextWithCFString(ret, CFCopyLocalizedString(CFSTR("Select Skin..."),"Slect Skin"), kMenuItemAttrIconDisabled, NULL,NULL);
 	AppendMenu(ret, "\p-");
 
 	base = np2tool.skin;
-    mkstr255(deftext, str_skindef);
-	AppendMenu(ret, deftext);
-	if (base[0] != '\0') {
-        EnableMenuItem(ret, 3);
+	AppendMenuItemTextWithCFString(ret, CFCopyLocalizedString(CFSTR("<Base Skin>"),"Base Skin"), kMenuItemAttrIconDisabled, NULL,NULL);
+	if (base[0] == '\0') {
+        CheckMenuItem(ret, BASENUMBER-1, true);
     }
 	for (cnt=0; cnt<SKINMRU_MAX; cnt++) {
 		p = np2tool.skinmru[cnt];
 		if (p[0] == '\0') {
 			break;
 		}
-		p = file_getname(p);
-		for (i=0; i<cnt; i++) {
-			if (file_cmpname(p, file[id[i]]) < 0) {
-				break;
-			}
-		}
-		for (j=cnt; j>i; j--) {
-			id[j] = id[j-1];
-		}
-		id[i] = cnt;
-		file[cnt] = p;
-	}
-	for (i=0; i<cnt; i++) {
-		j = id[i];
-        if (file[j][0] == '\0') {
-            AppendMenu(ret, "\pN/A");
+        UInt32	attr = kMenuItemAttrIconDisabled;
+        if (file_attr(p) != FILEATTR_ARCHIVE) {
+            attr |= kMenuItemAttrDisabled;
         }
-        else {
-            Str255	initext;
-            mkstr255(initext, file[j]);
-            AppendMenu(ret, initext);
+        ZeroMemory(longname, sizeof(longname));
+		if (!getLongFileName(longname, p)) {
+            strcpy(longname, file_getname(p));
         }
-        if (!file_cmpname(base, np2tool.skinmru[j])) {
-            EnableMenuItem(ret, 4+i);
+        AppendMenuItemTextWithCFString(ret, CFStringCreateWithCString(NULL, longname, kCFStringEncodingUTF8), attr, NULL, NULL);
+	}
+	for (i=0; i<cnt; i++) {
+        if (!file_cmpname(base, np2tool.skinmru[i])) {
+            CheckMenuItem(ret, i+BASENUMBER, true);
+            break;
         }
 	}
 	return;
 }
 
-static void skinchange(void) {
+static void skinchange(bool remake) {
 
 const char		*p;
 	UINT		i;
 
     toolwin_close();
 	p = np2tool.skin;
-	if (p[0]) {
+	if (p[0] && remake) {
 		for (i=0; i<(SKINMRU_MAX - 1); i++) {
 			if (!file_cmpname(p, np2tool.skinmru[i])) {
 				break;
@@ -699,24 +915,21 @@ const char		*p;
 
 
 // ----
-static void openpopup(HIPoint location) {
+static void openpopup(Point location) {
 
 	MenuRef	hMenu;
 	short	sel;
-    Str255	closetext;
     UInt16	selectclose;
     char	fname[MAX_PATH];
 
-    hMenu = NewMenu(222, "\pskin");
+    hMenu = NewMenu(222, "\pSkin");
     InsertMenu(hMenu, -1);
 	createskinmenu(hMenu);
 	AppendMenu(hMenu, "\p-");
-    mkstr255(closetext, str_toolclose);
-	AppendMenu(hMenu, closetext);
-
+    AppendMenuItemTextWithCFString(hMenu, CFCopyLocalizedString(CFSTR("Close"),"ToolWin Close"), kMenuItemAttrIconDisabled, NULL, NULL);
     DeleteMenu(222);
     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);
     if (sel == selectclose) {
         toolwin_close();
@@ -724,23 +937,27 @@ static void openpopup(HIPoint location) 
     else {
         switch (sel) {
             case 1:
-                if(dialog_fileselect(fname, sizeof(fname), hWndMain)) {
-                    if (file_getftype(fname)==FTYPE_TEXT) {
+                if(dialog_fileselect(fname, sizeof(fname), hWndMain, OPEN_INI)) {
+                    if (file_getftype(fname)==FTYPE_INI) {
                         strcpy(np2tool.skin, fname);
-                        skinchange();
+                        skinchange(true);
                     }
                 }
                 break;
             case 3:
-                np2tool.skin[0] = '\0';
-                skinchange();
+                if (np2tool.skin[0]) {
+                    np2tool.skin[0] = '\0';
+                    skinchange(false);
+                }
                 break;
             case 4:
             case 5:
             case 6:
             case 7:
-                file_cpyname(np2tool.skin, np2tool.skinmru[sel - 4], sizeof(np2tool.skin));
-                skinchange();
+                if (file_cmpname(np2tool.skin, np2tool.skinmru[sel - BASENUMBER])) {
+                    file_cpyname(np2tool.skin, np2tool.skinmru[sel - BASENUMBER], sizeof(np2tool.skin));
+                    skinchange(false);
+                }
                 break;
             default:
                 break;
@@ -749,21 +966,40 @@ 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) {
 
 	PicHandle	hbmp;
 	WindowRef	hWnd = NULL;
     Rect		bounds;
-    ControlRef	image;
-    EventTypeSpec	list[]={ 
-        { kEventClassControl, kEventControlContextualMenuClick },
-    };
-    EventHandlerRef	ref;
 
 	if (toolwin.hwnd) {
         toolwin_close();
 		return;
 	}
+    
+    checkOSVersion();
 	ZeroMemory(&toolwin, sizeof(toolwin));
 
 	hbmp = skinload(np2tool.skin, &bounds);
@@ -777,27 +1013,41 @@ void toolwin_open(void) {
 		goto twope_err2;
 	}
     
-    SizeWindow(hWnd, bounds.right-bounds.left, bounds.bottom-bounds.top, true);
-    ControlButtonContentInfo	info;
-    info.contentType = kControlContentPictHandle;
-    info.u.picture = hbmp;
-    CreatePictureControl(hWnd, &bounds, &info, true, &image);
-    InstallControlEventHandler (image, NewEventHandlerUPP(cfControlproc), GetEventTypeCount(list), list, (void *)hWnd, &ref);
-
-    toolwincreate(hWnd);
 
-#if 0
-    if (np2tool.posy < 30) np2tool.posy = 30;
-    if (np2tool.posx < 5 ) np2tool.posx = 5;
-    MoveWindow(hWnd, np2tool.posx, np2tool.posy, true);
-    ShowWindow(hWnd);
+	SetWindowBounds(hWnd, kWindowContentRgn, &bounds);
+	if (isPUMA) {
+        toolwincreate(hWnd);
+		makeskinimage(hWnd, hbmp, &bounds);
+    }
+	else {
+		makeskinimage(hWnd, hbmp, &bounds);
+        toolwincreate(hWnd);
+    }
+#ifndef AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+	opentoolwin_puma(hWnd);
 #else
-    SetDrawerParent(hWnd, hWndMain);
-    SetDrawerOffsets(hWnd, (640-(bounds.right-bounds.left))/2-11, (640-(bounds.right-bounds.left))/2-11);
-    SetDrawerPreferredEdge(hWnd, kWindowEdgeTop);
-    OpenDrawer(hWnd, kWindowEdgeDefault, 1);
+    if (isPUMA) {
+		opentoolwin_puma(hWnd);
+    }
+    else {
+        Rect	mainbounds;
+        int		width;
+        SetDrawerParent(hWnd, hWndMain);
+        GetWindowBounds(hWndMain, kWindowContentRgn, &mainbounds);
+        width = (mainbounds.right-mainbounds.left)-(bounds.right-bounds.left);
+        if (width/2-11<0) {
+            toolwin_close();
+            return;
+        }
+        SetDrawerOffsets(hWnd, width/2-11, width/2-11);
+        SetDrawerPreferredEdge(hWnd, kWindowEdgeTop);
+		const HISize  size = {bounds.right-bounds.left, bounds.bottom-bounds.top};
+		SetWindowResizeLimits(hWnd, &size, &size);
+        OpenDrawer(hWnd, kWindowEdgeDefault, 1);
+    }
 #endif
 
+    np2oscfg.toolwin = 1;
 	return;
 
 twope_err2:
@@ -811,11 +1061,22 @@ twope_err1:
 void toolwin_close(void) {
 
     if (toolwin.hwnd) {
-        CloseDrawer(toolwin.hwnd, 0);
+#ifndef AVAILABLE_MAC_OS_X_VERSION_10_2_AND_LATER
+        HideWindow(toolwin.hwnd);
+#else
+        if (isPUMA) {
+            HideWindow(toolwin.hwnd);
+        }
+        else {
+            CloseDrawer(toolwin.hwnd, 0);
+        }
+#endif
         RemoveReceiveHandler(dr, toolwin.hwnd);
+        RemoveTrackingHandler(tr, toolwin.hwnd);
         toolwindestroy();
         DisposeWindow(toolwin.hwnd);
         toolwin.hwnd = NULL;
+        np2oscfg.toolwin = 0;
     }
 }
 
@@ -932,6 +1193,7 @@ const DISKACC	*accterm;
 // ----
 
 static const char ini_title[] = "NP2 tool";
+static const char inifile[] = "np2.cfg";			// same file name..
 
 static const INITBL iniitem[] = {
 	{"WindposX", INITYPE_SINT32,	&np2tool.posx,			0},
@@ -959,12 +1221,6 @@ static const INITBL iniitem[] = {
 	{"FD2NAME7", INITYPE_STR,		np2tool.fdd[1].name[7],	MAX_PATH}};
 
 
-void initgetfile(char *path, UINT size) {
-
-	file_cpyname(path, file_getcd("np2"), size);
-    file_catname(path, ".ini", size);
-}
-
 void toolwin_readini(void) {
 
 	char	path[MAX_PATH];
@@ -972,7 +1228,7 @@ void toolwin_readini(void) {
 	ZeroMemory(&np2tool, sizeof(np2tool));
 	np2tool.posx = 0;
 	np2tool.posy = 0;
-	initgetfile(path, sizeof(path));
+	file_cpyname(path, file_getcd(inifile), sizeof(path));
 	ini_read(path, ini_title, iniitem, sizeof(iniitem)/sizeof(INITBL));
 }
 
@@ -980,6 +1236,7 @@ void toolwin_writeini(void) {
 
 	char	path[MAX_PATH];
 
-	initgetfile(path, sizeof(path));
-	ini_write(path, ini_title, iniitem, sizeof(iniitem)/sizeof(INITBL));
+	file_cpyname(path, file_getcd(inifile), sizeof(path));
+	ini_write(path, ini_title, iniitem, sizeof(iniitem)/sizeof(INITBL), FALSE);
 }
+