diff --git a/ANNOUNCE b/ANNOUNCE
index d5d35fe..a999ecd 100644
--- a/ANNOUNCE
+++ b/ANNOUNCE
@@ -1,12 +1,13 @@
-This is release 961102 of Wine, the MS Windows emulator.  This is still a
+This is release 961117 of Wine, the MS Windows emulator.  This is still a
 developer's only release.  There are many bugs and many unimplemented API
 features.  Most applications still do not work correctly.
 
 Patches should be submitted to "julliard@lrc.epfl.ch".  Please don't
 forget to include a ChangeLog entry.
 
-WHAT'S NEW with Wine-961102: (see ChangeLog for details)
+WHAT'S NEW with Wine-961117: (see ChangeLog for details)
 	- More Win32 functions.
+	- OffiX-style drag and drop.
 	- Lots of bug fixes.
 
 See the README file in the distribution for installation instructions.
@@ -15,10 +16,10 @@
 the release is available at the ftp sites.  The sources will be available
 from the following locations:
 
-  ftp://sunsite.unc.edu/pub/Linux/ALPHA/wine/development/Wine-961102.tar.gz
-  ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/development/Wine-961102.tar.gz
-  ftp://ftp.infomagic.com/pub/mirrors/linux/wine/development/Wine-961102.tar.gz
-  ftp://aris.com/pub/linux/ALPHA/Wine/development/Wine-961102.tar.gz
+  ftp://sunsite.unc.edu/pub/Linux/ALPHA/wine/development/Wine-961117.tar.gz
+  ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/development/Wine-961117.tar.gz
+  ftp://ftp.infomagic.com/pub/mirrors/linux/wine/development/Wine-961117.tar.gz
+  ftp://aris.com/pub/linux/ALPHA/Wine/development/Wine-961117.tar.gz
 
 It should also be available from any site that mirrors tsx-11 or sunsite.
 
diff --git a/BUGS b/BUGS
index 1148443..4785851 100644
--- a/BUGS
+++ b/BUGS
@@ -1,20 +1,45 @@
-1. Messaging:
+This is intended to be a place where you should look first if
+you want to contribute to Wine development. Add your e-mail
+address to the corresponding entry if you are working on/have 
+done something for one of the problems. You are encouraged to 
+add new entries and, more importantly, remove those for the 
+bugs you fixed ;-)
+------------------------------------------------------------
+As of Nov 8 1996 -
 
-- Message flow is not correct for multiple tasks
-- Dialog Boxes created by WM_CREATE handler aren't visible
-- MDI does not send WM_GETMINMAX message.
-- resizing of MDI child windows sometimes leaves them unrepainted
+General:
 
-2. Controls:
+ * Combobox code is very inadequate (no notification messages,
+   dropdown listboxes often stay visible, etc... ).
 
-- Some features are missing (like VK_SHIFT aided multiple selection in listboxes)
+ * Multicolumn and/or LBS_EXTENDEDSEL style listboxes are still 
+   screwed up. [julliard@lrc.epfl.ch]
 
-3. Miscellaneous:
+ * Winsock asynchronous functions do not work.
 
-- AllocCSToDSAlias() shouldn't alloc alias for the same segment multiple times.
+ * Font mapping is too generic. No soft font loading, no rotated 
+   text support. [alex@amadeus.pharm.sunysb.edu]
 
-4. Where to look in source files:
+ * No thread support in Win32 code. 
 
-- grep for FIXME in the source files.
+ * Very alpha printing code. [john@division.co.uk]
+
+ * No icon titles.
+	- Windows uses a special window class to display icon titles.
+	  Handles to these title windows are stored in the icon window
+	  properties.
+
+Miscellaneous:
+
+ * AllocCSToDSAlias() shouldn't alloc alias for the same segment multiple
+   times.
+ * ScrollWindowEx() is outdated.
+ * HCBT_CLICKSKIPPED/HCBT_KEYSKIPPED hook actions are not implemented.
+ * Write sometimes segfaults in StretchDIBits() (when inside BITBLT_GetRow)
+   when only lower part of the resulting image is visible.
+
+Where to look in source files:
+
+ * grep for FIXME in the source files.
 
 
diff --git a/ChangeLog b/ChangeLog
index fec97dd..d848a91 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,109 @@
 ----------------------------------------------------------------------
+Sun Nov 17 15:01:45 1996  Alexandre Julliard  <julliard@lrc.epfl.ch>
+
+	* [graphics/bitblt.c] [graphics/x11drv/bitblt.c]
+	Moved BitBlt operations to the new graphics driver
+	interface. Implemented PatBlt32, BitBlt32 and StretchBlt32.
+
+	* [memory/global.c]
+	Unified MemManInfo() and GlobalMemoryStatus().
+
+	* [objects/text.c]
+	Fixed ExtTextOut() to always use physical coords for clip rect.
+
+	* [windows/dialog.c]
+	Implemented DlgDirSelectEx() and Win32 version of DlgDirSelect*.
+
+	* [windows/event.c]
+	Avoid busy-looping in EVENT_WaitXEvent when no timer is pending
+	(thanks to Thomas Koenig).
+
+	* [windows/painting.c]
+	Moved update region clipping for CS_PARENTDC windows to BeginPaint().
+	
+	* [windows/scroll.c]
+	Implemented Win32 version of ScrollWindow() and ScrollDC().
+
+Tue Nov 12 09:52:17 1996  Marcus Meissner <msmeissn@cip.informatik.uni-erlangen.de>
+
+	* [files/*.c] [win32/file.c]
+	Some win32 filetime conversion functions added.
+	Fixed behaviour with DOS drives pointing to UNIX /
+	SetCurrentDirectory() may also get X:\xxx paths.
+	Fixed FILE_Open when called from CreateFile().
+	Added GetFileSize(), MapViewOfFile(), SetFileTime(), GetFileTime().
+
+	* [misc/crtdll.c] [if1632/crtdll.spec]
+	Added some new functions.
+
+	* [if1632/user32.spec]
+	Some thunks into win16 code added.
+
+	* [win32/init.c]
+	Added GetSystemInfo(), removed GetModuleFileName() stub.
+
+	* [win32/code_page.c] [if1632/thunk.c]
+	Added EnumSystemCodePages* (untested).
+
+	* [objects/font.c] [if1632/thunk.c]
+	Added EnumFontFamilies32*.
+	
+Mon Nov 11 14:50:24 1996  Huw D. M. Davies <h.davies1@physics.oxford.ac.uk>
+
+	* [controls/menu.c] [windows/mdi.c]
+	Don't delete the MDI `windows' menu if it's already been deleted.
+
+	* [misc/exec.c]
+	Notepad always calls WinHelp(.., HELP_QUIT, ...) at termination
+ 	and complains if it returns FALSE.
+
+	* [windows/winpos.c]
+	Get maximized MDI child's nonclient area redrawn after resize.
+
+Thu Nov  7 13:32:34 1996  Lee Jaekil <juria@seodu.co.kr>
+
+	* [memory/global.c]
+	Use /proc filesystem for GlobalMemoryStatus() on Linux.
+
+Mon Nov  4 18:30:00 1996  Alex Korobka <alex@trantor.pharm.sunysb.edu>
+
+	* [windows/event.c]
+	Added OffiX-style file drop handling. File paths must be
+	DOS-mappable by Wine (via wine.conf).
+
+	* [controls/combo.c]
+        Added WM_GETTEXT handler.
+
+	* [objects/palette.c]
+	Added ResizePalette() (untested).
+
+	* [objects/cursoricon.c]
+	Implemented icon to cursor conversion.
+
+	* [objects/color.c]
+	Fixed crash on startup when no colorcells are writeable.
+
+Mon Nov  4 00:49:41 1996  Ulrich Schmid  <uschmid@mail.hh.provi.de>
+
+	* [rc/winerc.c]
+	Added support for win32 output.
+
+	* [library/libres.c] [include/libres.h] [loader/resource.c]
+	Renamed LIBRES_FindResource to LIBRES_FindResource16.
+	Added LIBRES_FindResource32.
+
+Sun Nov 3 21:21:45 1996  Robert Pouliot <krynos@clic.net>
+
+	* [loader/builtin.c] [if1632/Makefile.in] [if1632/wing.spec]
+	Added the spec file for WinG, it's only stub for now, but it
+	should be easy to do by someone with Windows programming
+	knowledge. See: ftp.microsoft.com/SoftLib/MSLFILES/wing10.exe.
+
+	* [if1632/crtdll.spec]
+	Added some string and memory functions to make sfxed95.exe (of
+ 	Warcraft 2) almost work.
+
+----------------------------------------------------------------------
 Sat Nov  2 12:50:40 1996  Alexandre Julliard  <julliard@lrc.epfl.ch>
 
 	* [files/dos_fs.c]
diff --git a/Make.rules.in b/Make.rules.in
index 43d024a..f8d1c90 100644
--- a/Make.rules.in
+++ b/Make.rules.in
@@ -52,7 +52,7 @@
 	echo "#include \"windows.h\"" >winerctmp.c
 	echo WINDOWS_H_ENDS_HERE >>winerctmp.c
 	cat $< >>winerctmp.c
-	$(CPP) $(DEFS) $(OPTIONS) $(DIVINCL) -DRC_INVOKED -P winerctmp.c | sed -e '1,/^WINDOWS_H_ENDS_HERE/d' | $(WINERC) -c -o $* -p $*
+	$(CPP) $(DEFS) $(OPTIONS) $(DIVINCL) -DRC_INVOKED -P winerctmp.c | sed -e '1,/^WINDOWS_H_ENDS_HERE/d' | $(WINERC) $(RCFLAGS) -c -o $* -p $*
 	$(RM) winerctmp.c
 
 .rc.h:
diff --git a/controls/button.c b/controls/button.c
index 8d92822..3367a66 100644
--- a/controls/button.c
+++ b/controls/button.c
@@ -284,8 +284,8 @@
     {
         /* draw button shadow: */
         SelectObject32(hDC, sysColorObjects.hbrushBtnShadow );
-        PatBlt(hDC, rc.left, rc.top, 1, rc.bottom-rc.top, PATCOPY );
-        PatBlt(hDC, rc.left, rc.top, rc.right-rc.left, 1, PATCOPY );
+        PatBlt32(hDC, rc.left, rc.top, 1, rc.bottom-rc.top, PATCOPY );
+        PatBlt32(hDC, rc.left, rc.top, rc.right-rc.left, 1, PATCOPY );
         rc.left += 2;  /* To position the text down and right */
         rc.top  += 2;
     }
@@ -352,12 +352,12 @@
     SelectObject32( hdcMem, hbmMem);
     hBr = SelectObject32( hdcMem, CreatePatternBrush32(hbm) );
     DeleteObject32( hbm );
-    PatBlt( hdcMem,0,0,rect.right,rect.bottom,WHITENESS);
+    PatBlt32( hdcMem,0,0,rect.right,rect.bottom,WHITENESS);
     if (hFont) SelectObject32( hdcMem, hFont);
     DrawText32A( hdcMem, text, -1, &rc2, DT_SINGLELINE);  
-    PatBlt( hdcMem,0,0,rect.right,rect.bottom,0xFA0089);
+    PatBlt32( hdcMem,0,0,rect.right,rect.bottom,0xFA0089);
     DeleteObject32( SelectObject32( hdcMem,hBr) );
-    BitBlt( hDC,rect.left,rect.top,rect.right,rect.bottom,hdcMem,0,0,0x990000);
+    BitBlt32(hDC,rect.left,rect.top,rect.right,rect.bottom,hdcMem,0,0,0x990000);
     DeleteDC( hdcMem);
     DeleteObject32( hbmMem );
 }
diff --git a/controls/combo.c b/controls/combo.c
index c3f429e..43a368b 100644
--- a/controls/combo.c
+++ b/controls/combo.c
@@ -21,7 +21,6 @@
 #include "graphics.h"
 #include "heap.h"
 #include "listbox.h"
-#include "dos_fs.h"
 #include "drive.h"
 #include "stddebug.h"
 #include "debug.h"
@@ -289,7 +288,7 @@
 static LRESULT CBLButtonDown(HWND hwnd, WPARAM16 wParam, LPARAM lParam)
 {
   LPHEADCOMBO lphc = ComboGetStorageHeader(hwnd);
-  SendMessage16(hwnd,CB_SHOWDROPDOWN,!lphc->DropDownVisible,0);
+  SendMessage16(hwnd,CB_SHOWDROPDOWN16,!lphc->DropDownVisible,0);
   return 0;
 }
 
@@ -774,6 +773,15 @@
     return SendMessage16(lphc->hWndEdit, EM_SETSEL, 0, lParam);
 }
 
+/***********************************************************************
+ *           CBGetText
+ */
+static LRESULT CBGetText(HWND hwnd, WPARAM16 wParam, LPARAM lParam)
+{
+    LPHEADCOMBO lphc = ComboGetStorageHeader(hwnd);
+
+    return SendMessage16(lphc->hWndEdit, WM_GETTEXT, wParam, lParam);   
+}
 
 /***********************************************************************
  *           ComboWndProc
@@ -790,31 +798,32 @@
      case WM_SETFONT: return CBSetFont(hwnd, wParam, lParam);
      case WM_SETREDRAW: return CBSetRedraw(hwnd, wParam, lParam);
      case WM_PAINT: return CBPaint(hwnd, wParam, lParam);
+     case WM_GETTEXT: return CBGetText( hwnd, wParam, lParam);
      case WM_LBUTTONDOWN: return CBLButtonDown(hwnd, wParam, lParam);
      case WM_SETFOCUS: return CBSetFocus(hwnd, wParam, lParam);
      case WM_KILLFOCUS: return CBKillFocus(hwnd, wParam, lParam);
      case WM_SIZE: return CBCheckSize(hwnd);
      case WM_COMMAND: return CBCommand(hwnd, wParam, lParam);
-     case CB_RESETCONTENT: return CBResetContent(hwnd, wParam, lParam);
-     case CB_DIR: return CBDir(hwnd, wParam, lParam);
-     case CB_ADDSTRING: return CBAddString(hwnd, wParam, lParam);
-     case CB_INSERTSTRING: return CBInsertString(hwnd, wParam, lParam);
-     case CB_DELETESTRING: return CBDeleteString(hwnd, wParam, lParam);
-     case CB_FINDSTRING: return CBFindString(hwnd, wParam, lParam);
-     case CB_GETCOUNT: return CBGetCount(hwnd, wParam, lParam);
-     case CB_GETCURSEL: return CBGetCurSel(hwnd, wParam, lParam);
-     case CB_GETITEMDATA: return CBGetItemData(hwnd, wParam, lParam);
-     case CB_GETITEMHEIGHT: return CBGetItemHeight(hwnd, wParam, lParam);
-     case CB_GETLBTEXT: return CBGetLBText(hwnd, wParam, lParam);
-     case CB_GETLBTEXTLEN: return CBGetLBTextLen(hwnd, wParam, lParam);
-     case CB_SELECTSTRING: return CBSelectString(hwnd, wParam, lParam);
-     case CB_SETITEMDATA: return CBSetItemData(hwnd, wParam, lParam);
-     case CB_SETCURSEL: return CBSetCurSel(hwnd, wParam, lParam);
-     case CB_SETITEMHEIGHT: return CBSetItemHeight(hwnd, wParam, lParam);
-     case CB_SHOWDROPDOWN: return CBShowDropDown(hwnd, wParam, lParam);
-     case CB_GETEDITSEL: return CBGetEditSel(hwnd, wParam, lParam);
-     case CB_SETEDITSEL: return CBSetEditSel(hwnd, wParam, lParam);
-     case CB_FINDSTRINGEXACT: return CBFindStringExact(hwnd, wParam, lParam);
+     case CB_RESETCONTENT16: return CBResetContent(hwnd, wParam, lParam);
+     case CB_DIR16: return CBDir(hwnd, wParam, lParam);
+     case CB_ADDSTRING16: return CBAddString(hwnd, wParam, lParam);
+     case CB_INSERTSTRING16: return CBInsertString(hwnd, wParam, lParam);
+     case CB_DELETESTRING16: return CBDeleteString(hwnd, wParam, lParam);
+     case CB_FINDSTRING16: return CBFindString(hwnd, wParam, lParam);
+     case CB_GETCOUNT16: return CBGetCount(hwnd, wParam, lParam);
+     case CB_GETCURSEL16: return CBGetCurSel(hwnd, wParam, lParam);
+     case CB_GETITEMDATA16: return CBGetItemData(hwnd, wParam, lParam);
+     case CB_GETITEMHEIGHT16: return CBGetItemHeight(hwnd, wParam, lParam);
+     case CB_GETLBTEXT16: return CBGetLBText(hwnd, wParam, lParam);
+     case CB_GETLBTEXTLEN16: return CBGetLBTextLen(hwnd, wParam, lParam);
+     case CB_SELECTSTRING16: return CBSelectString(hwnd, wParam, lParam);
+     case CB_SETITEMDATA16: return CBSetItemData(hwnd, wParam, lParam);
+     case CB_SETCURSEL16: return CBSetCurSel(hwnd, wParam, lParam);
+     case CB_SETITEMHEIGHT16: return CBSetItemHeight(hwnd, wParam, lParam);
+     case CB_SHOWDROPDOWN16: return CBShowDropDown(hwnd, wParam, lParam);
+     case CB_GETEDITSEL16: return CBGetEditSel(hwnd, wParam, lParam);
+     case CB_SETEDITSEL16: return CBSetEditSel(hwnd, wParam, lParam);
+     case CB_FINDSTRINGEXACT16: return CBFindStringExact(hwnd, wParam, lParam);
     }
     return DefWindowProc16(hwnd, message, wParam, lParam);
 }
@@ -988,7 +997,7 @@
  */
 static LRESULT CBLKillFocus( HWND hwnd, WPARAM16 wParam, LPARAM lParam )
 {
-/*  SendMessage16(CLBoxGetCombo(hwnd),CB_SHOWDROPDOWN,0,0);*/
+/*  SendMessage16(CLBoxGetCombo(hwnd),CB_SHOWDROPDOWN16,0,0);*/
   return 0;
 }
 
@@ -998,7 +1007,7 @@
 static LRESULT CBLActivate( HWND hwnd, WPARAM16 wParam, LPARAM lParam )
 {
   if (wParam == WA_INACTIVE)
-    SendMessage16(CLBoxGetCombo(hwnd),CB_SHOWDROPDOWN,0,0);
+    SendMessage16(CLBoxGetCombo(hwnd),CB_SHOWDROPDOWN16,0,0);
   return 0;
 }
 
@@ -1042,12 +1051,12 @@
      }
   else if (lphl->PrevFocused != lphl->ItemFocused) 
           {
-      		SendMessage16(CLBoxGetCombo(hwnd),CB_SETCURSEL,lphl->ItemFocused,0);
+      		SendMessage16(CLBoxGetCombo(hwnd),CB_SETCURSEL16,lphl->ItemFocused,0);
       		SendMessage16(GetParent16(hwnd), WM_COMMAND,ID_CLB,MAKELONG(0,CBN_SELCHANGE));
       		ListBoxSendNotification(lphl, CBN_SELCHANGE);
      	  }
 
-  SendMessage16(CLBoxGetCombo(hwnd),CB_SHOWDROPDOWN,0,0);
+  SendMessage16(CLBoxGetCombo(hwnd),CB_SHOWDROPDOWN16,0,0);
 
   return 0;
 }
@@ -1225,15 +1234,6 @@
     return DefWindowProc16(hwnd, message, wParam, lParam);
 }
 
-/************************************************************************
- * 			       	DlgDirSelectComboBox	[USER.194]
- */
-BOOL DlgDirSelectComboBox(HWND hDlg, LPSTR lpStr, INT nIDLBox)
-{
-	fprintf(stdnimp,"DlgDirSelectComboBox(%04x, '%s', %d) \n",
-				hDlg, lpStr, nIDLBox);
-	return TRUE;
-}
 
 static INT32 COMBO_DlgDirList( HWND32 hDlg, LPARAM path, INT32 idCBox,
                                INT32 idStatic, UINT32 wType, BOOL32 unicode )
@@ -1242,11 +1242,11 @@
 
     if (idCBox)
     {
-        SendDlgItemMessage32A( hDlg, idCBox, CB_RESETCONTENT, 0, 0 );
+        SendDlgItemMessage32A( hDlg, idCBox, CB_RESETCONTENT16, 0, 0 );
         if (unicode)
-            res = SendDlgItemMessage32W( hDlg, idCBox, CB_DIR, wType, path );
+            res = SendDlgItemMessage32W( hDlg, idCBox, CB_DIR16, wType, path );
         else
-            res = SendDlgItemMessage32A( hDlg, idCBox, CB_DIR, wType, path );
+            res = SendDlgItemMessage32A( hDlg, idCBox, CB_DIR16, wType, path );
     }
     if (idStatic)
     {
diff --git a/controls/edit.c b/controls/edit.c
index e86af14..66baa58 100644
--- a/controls/edit.c
+++ b/controls/edit.c
@@ -1879,7 +1879,7 @@
 		if (wndPtr->hwndSelf == GetFocus32())
 			HideCaret(wndPtr->hwndSelf);
 		if (EDIT_GetRedraw(wndPtr)) 
-			ScrollWindow(wndPtr->hwndSelf, dx, dy, NULL, NULL);
+			ScrollWindow32(wndPtr->hwndSelf, dx, dy, NULL, NULL);
 		es->FirstVisibleLine = nfv;
 		es->XOffset = nxoff;
 		if (IsVScrollBar(wndPtr))
diff --git a/controls/listbox.c b/controls/listbox.c
index 1fe77b2..a07645d 100644
--- a/controls/listbox.c
+++ b/controls/listbox.c
@@ -2176,43 +2176,6 @@
 
 
 /**********************************************************************
- *	    DlgDirSelect    (USER.99)
- */
-BOOL DlgDirSelect( HWND hDlg, LPSTR lpStr, INT id )
-{
-    char *buffer;
-    INT i;
-
-    dprintf_listbox( stddeb, "DlgDirSelect: %04x '%s' %d\n", hDlg, lpStr, id );
-    if ((i = SendDlgItemMessage16( hDlg, id, LB_GETCURSEL16, 0, 0 )) == LB_ERR)
-        return FALSE;
-    if (!(buffer = SEGPTR_ALLOC( 20 * sizeof(char) ))) return FALSE;
-    SendDlgItemMessage16(hDlg, id, LB_GETTEXT16, i, (LPARAM)SEGPTR_GET(buffer) );
-    if (buffer[0] == '[')  /* drive or directory */
-    {
-        if (buffer[1] == '-')  /* drive */
-        {
-            lpStr[0] = buffer[2];
-            lpStr[1] = ':';
-            lpStr[2] = '\0';
-            dprintf_listbox( stddeb, "Returning drive '%s'\n", lpStr );
-            SEGPTR_FREE(buffer);
-            return TRUE;
-        }
-        strcpy( lpStr, buffer + 1 );
-        lpStr[strlen(lpStr)-1] = '\\';
-        dprintf_listbox( stddeb, "Returning directory '%s'\n", lpStr );
-        SEGPTR_FREE(buffer);
-        return TRUE;
-    }
-    strcpy( lpStr, buffer );
-    dprintf_listbox( stddeb, "Returning file '%s'\n", lpStr );
-    SEGPTR_FREE(buffer);
-    return FALSE;
-}
-
-
-/**********************************************************************
  *	    DlgDirList    (USER.100)
  */
 INT DlgDirList( HWND hDlg, SEGPTR spec, INT idLBox, INT idStatic, UINT attrib )
diff --git a/controls/menu.c b/controls/menu.c
index 8443376..59cee28 100644
--- a/controls/menu.c
+++ b/controls/menu.c
@@ -2173,7 +2173,7 @@
 	LPPOPUPMENU	menu;
 	dprintf_menu(stddeb,"GetMenuItemCount(%04x);\n", hMenu);
 	menu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu);
-	if (menu == NULL) return (UINT)-1;
+	if (menu == NULL || menu->wMagic != MENU_MAGIC) return (UINT)-1;
 	dprintf_menu(stddeb,"GetMenuItemCount(%04x) return %d \n", 
 		     hMenu, menu->nItems);
 	return menu->nItems;
diff --git a/controls/scroll.c b/controls/scroll.c
index 481f6cb..21316a0 100644
--- a/controls/scroll.c
+++ b/controls/scroll.c
@@ -48,7 +48,7 @@
 #define SCROLL_MIN_RECT  4  
 
   /* Minimum size of the thumb in pixels */
-#define SCROLL_MIN_THUMB 4
+#define SCROLL_MIN_THUMB 6
 
   /* Delay (in ms) before first repetition when holding the button down */
 #define SCROLL_FIRST_DELAY   200
@@ -316,28 +316,28 @@
                                     TOP_ARROW(infoPtr->flags, top_pressed)
                                     : LEFT_ARROW(infoPtr->flags, top_pressed));
     SetStretchBltMode( hdc, STRETCH_DELETESCANS );
-    StretchBlt( hdc, rect->left, rect->top,
-                vertical ? rect->right-rect->left : arrowSize+1,
-                vertical ? arrowSize+1 : rect->bottom-rect->top,
-                hdcMem, 0, 0,
-                SYSMETRICS_CXVSCROLL + 1, SYSMETRICS_CYHSCROLL + 1,
-                SRCCOPY );
+    StretchBlt32( hdc, rect->left, rect->top,
+                  vertical ? rect->right-rect->left : arrowSize+1,
+                  vertical ? arrowSize+1 : rect->bottom-rect->top,
+                  hdcMem, 0, 0,
+                  SYSMETRICS_CXVSCROLL + 1, SYSMETRICS_CYHSCROLL + 1,
+                  SRCCOPY );
 
     SelectObject32( hdcMem, vertical ?
                     BOTTOM_ARROW( infoPtr->flags, bottom_pressed )
                     : RIGHT_ARROW( infoPtr->flags, bottom_pressed ) );
     if (vertical)
-        StretchBlt( hdc, rect->left, rect->bottom - arrowSize - 1,
-                   rect->right - rect->left, arrowSize + 1,
-                   hdcMem, 0, 0,
-                   SYSMETRICS_CXVSCROLL + 1, SYSMETRICS_CYHSCROLL + 1,
-                   SRCCOPY );
+        StretchBlt32( hdc, rect->left, rect->bottom - arrowSize - 1,
+                      rect->right - rect->left, arrowSize + 1,
+                      hdcMem, 0, 0,
+                      SYSMETRICS_CXVSCROLL + 1, SYSMETRICS_CYHSCROLL + 1,
+                      SRCCOPY );
     else
-        StretchBlt( hdc, rect->right - arrowSize - 1, rect->top,
-                   arrowSize + 1, rect->bottom - rect->top,
-                   hdcMem, 0, 0,
-                   SYSMETRICS_CXVSCROLL + 1, SYSMETRICS_CYHSCROLL + 1,
-                   SRCCOPY );
+        StretchBlt32( hdc, rect->right - arrowSize - 1, rect->top,
+                      arrowSize + 1, rect->bottom - rect->top,
+                      hdcMem, 0, 0,
+                      SYSMETRICS_CXVSCROLL + 1, SYSMETRICS_CYHSCROLL + 1,
+                      SRCCOPY );
     SelectObject32( hdcMem, hbmpPrev );
     DeleteDC( hdcMem );
 }
@@ -432,35 +432,35 @@
 
     if (!thumbPos)  /* No thumb to draw */
     {
-        PatBlt( hdc, r.left+1, r.top+1, r.right - r.left - 2,
-                r.bottom - r.top - 2, PATCOPY );
+        PatBlt32( hdc, r.left+1, r.top+1, r.right - r.left - 2,
+                  r.bottom - r.top - 2, PATCOPY );
         return;
     }
 
     if (vertical)
     {
-        PatBlt( hdc, r.left + 1, r.top + 1,
-                r.right - r.left - 2,
-                thumbPos - arrowSize,
-                top_selected ? 0x0f0000 : PATCOPY );
+        PatBlt32( hdc, r.left + 1, r.top + 1,
+                  r.right - r.left - 2,
+                  thumbPos - arrowSize,
+                  top_selected ? 0x0f0000 : PATCOPY );
         r.top += thumbPos - arrowSize;
-        PatBlt( hdc, r.left + 1, r.top + thumbSize + 1,
-                r.right - r.left - 2,
-                r.bottom - r.top - thumbSize - 2,
-                bottom_selected ? 0x0f0000 : PATCOPY );
+        PatBlt32( hdc, r.left + 1, r.top + thumbSize + 1,
+                  r.right - r.left - 2,
+                  r.bottom - r.top - thumbSize - 2,
+                  bottom_selected ? 0x0f0000 : PATCOPY );
         r.bottom = r.top + thumbSize + 1;
     }
     else  /* horizontal */
     {
-        PatBlt( hdc, r.left + 1, r.top + 1,
-                thumbPos - arrowSize,
-                r.bottom - r.top - 2,
-                top_selected ? 0x0f0000 : PATCOPY );
+        PatBlt32( hdc, r.left + 1, r.top + 1,
+                  thumbPos - arrowSize,
+                  r.bottom - r.top - 2,
+                  top_selected ? 0x0f0000 : PATCOPY );
         r.left += thumbPos - arrowSize;
-        PatBlt( hdc, r.left + thumbSize + 1, r.top + 1,
-                r.right - r.left - thumbSize - 2,
-                r.bottom - r.top - 2,
-                bottom_selected ? 0x0f0000 : PATCOPY );
+        PatBlt32( hdc, r.left + thumbSize + 1, r.top + 1,
+                  r.right - r.left - thumbSize - 2,
+                  r.bottom - r.top - 2,
+                  bottom_selected ? 0x0f0000 : PATCOPY );
         r.right = r.left + thumbSize + 1;
     }
 
diff --git a/controls/widgets.c b/controls/widgets.c
index 0235053..88d01a4 100644
--- a/controls/widgets.c
+++ b/controls/widgets.c
@@ -16,6 +16,8 @@
 #include "module.h"
 #include "heap.h"
 
+#define OLD_LISTBOX
+
 typedef struct
 {
     UINT16     style;
@@ -29,8 +31,10 @@
 {
     { CS_GLOBALCLASS | CS_PARENTDC,
        sizeof(STATICINFO), 0, "StaticWndProc", "STATIC" },
+#ifdef OLD_LISTBOX
     { CS_GLOBALCLASS | CS_PARENTDC | CS_DBLCLKS,
       8, 0, "ListBoxWndProc", "LISTBOX" },
+#endif
     { CS_GLOBALCLASS | CS_PARENTDC | CS_DBLCLKS,
       8, 0, "ComboBoxWndProc", "COMBOBOX" },
     { CS_GLOBALCLASS | CS_DBLCLKS | CS_SAVEBITS,
@@ -53,6 +57,10 @@
 {
     { CS_GLOBALCLASS | CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW | CS_PARENTDC,
       ButtonWndProc, 0, sizeof(BUTTONINFO), 0, 0, 0, 0, 0, "BUTTON" },
+#ifndef OLD_LISTBOX
+    { CS_GLOBALCLASS | CS_DBLCLKS /*| CS_PARENTDC*/,
+      ListBoxWndProc32, 0, sizeof(void *), 0, 0, 0, 0, 0, "LISTBOX" },
+#endif
     { CS_GLOBALCLASS | CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW | CS_PARENTDC,
       ScrollBarWndProc, 0, sizeof(SCROLLBAR_INFO), 0, 0, 0, 0, 0, "SCROLLBAR"},
     { CS_GLOBALCLASS, DesktopWndProc, 0, sizeof(DESKTOPINFO),
diff --git a/documentation/user_module b/documentation/user_module
index 4335f9c..8cff4cb 100644
--- a/documentation/user_module
+++ b/documentation/user_module
@@ -213,5 +213,4 @@
        and in this case SendMessage has to build some sort of message 
        queue for sent messages. Another issue is what to do with messages 
        sent to the sender when it is blocked inside its own SendMessage. 
-       At this point Wine addresses very few of these problems.
 
diff --git a/files/dos_fs.c b/files/dos_fs.c
index 3e3c8dc..77aa5ed 100644
--- a/files/dos_fs.c
+++ b/files/dos_fs.c
@@ -306,6 +306,25 @@
                  + tm->tm_mday;
 }
 
+/***********************************************************************
+ *           DOSFS_DosDateTimeToUnixTime
+ *
+ * Convert from the DOS (FAT) date/time format into Unix time
+ * (borrowed from files/file.c)
+ */
+time_t DOSFS_DosDateTimeToUnixTime( WORD date, WORD time )
+{
+    struct tm newtm;
+
+    newtm.tm_sec  = (time & 0x1f) * 2;
+    newtm.tm_min  = (time >> 5) & 0x3f;
+    newtm.tm_hour = (time >> 11);
+    newtm.tm_mday = (date & 0x1f);
+    newtm.tm_mon  = ((date >> 5) & 0x0f) - 1;
+    newtm.tm_year = (date >> 9) + 80;
+    return mktime( &newtm );
+}
+
 
 /***********************************************************************
  *           DOSFS_UnixTimeToFileTime
@@ -760,7 +779,8 @@
                        path, skip, buffer, cur_pos );
         cur_pos = skip;
         if (dir) closedir(dir);
-        if (!(dir = opendir( path ))) return 0;
+        if (!*path) path = "/";
+        if (!(dir = opendir(path))) return 0;
         drive_path = path;
         drive_root = 0;
         if (DRIVE_FindDriveRoot( &drive_path ) != -1)
@@ -876,3 +896,94 @@
 		*lastpart=strrchr(buf,'\\');
 	return strlen(fn);
 }
+
+
+/***********************************************************************
+ *           DosDateTimeToFileTime   (KERNEL32.76)
+ */
+BOOL32 DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft )
+{
+    time_t unixtime = DOSFS_DosDateTimeToUnixTime(fatdate,fattime);
+    DOSFS_UnixTimeToFileTime(unixtime,ft);
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           FileTimeToDosDateTime   (KERNEL32.111)
+ */
+BOOL32 FileTimeToDosDateTime( LPFILETIME ft, LPWORD fatdate, LPWORD fattime)
+{
+    time_t unixtime = DOSFS_FileTimeToUnixTime(ft);
+    DOSFS_ToDosDateTime(unixtime,fatdate,fattime);
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           LocalFileTimeToFileTime   (KERNEL32.373)
+ */
+BOOL32 LocalFileTimeToFileTime( LPFILETIME localft, LPFILETIME utcft )
+{
+    struct tm *xtm;
+
+    /* convert from local to UTC. Perhaps not correct. FIXME */
+    xtm = gmtime((time_t*)&(localft->dwLowDateTime));
+    utcft->dwLowDateTime  = mktime(xtm);
+    utcft->dwHighDateTime = 0;
+    return TRUE; 
+}
+
+
+/***********************************************************************
+ *           FileTimeToLocalFileTime   (KERNEL32.112)
+ */
+BOOL32 FileTimeToLocalFileTime( LPFILETIME utcft, LPFILETIME localft )
+{
+    struct tm *xtm;
+
+    /* convert from UTC to local. Perhaps not correct. FIXME */
+    xtm = localtime((time_t*)&(utcft->dwLowDateTime));
+    localft->dwLowDateTime  = mktime(xtm);
+    localft->dwHighDateTime = 0;
+    return TRUE; 
+}
+
+
+/***********************************************************************
+ *           FileTimeToSystemTime   (KERNEL32.113)
+ */
+BOOL32 FileTimeToSystemTime( LPFILETIME ft, LPSYSTEMTIME syst )
+{
+    struct tm *xtm;
+    time_t xtime = DOSFS_FileTimeToUnixTime(ft);
+    xtm = gmtime(&xtime);
+    syst->wYear      = xtm->tm_year;
+    syst->wMonth     = xtm->tm_mon;
+    syst->wDayOfWeek = xtm->tm_wday;
+    syst->wDay	     = xtm->tm_mday;
+    syst->wHour	     = xtm->tm_hour;
+    syst->wMinute    = xtm->tm_min;
+    syst->wSecond    = xtm->tm_sec;
+    syst->wMilliseconds	= 0; /* FIXME */
+    return TRUE; 
+}
+
+
+/***********************************************************************
+ *           SystemTimeToFileTime   (KERNEL32.526)
+ */
+BOOL32 SystemTimeToFileTime( LPSYSTEMTIME syst, LPFILETIME ft )
+{
+    struct tm xtm;
+
+    xtm.tm_year	= syst->wYear;
+    xtm.tm_mon	= syst->wMonth;
+    xtm.tm_wday	= syst->wDayOfWeek;
+    xtm.tm_mday	= syst->wDay;
+    xtm.tm_hour	= syst->wHour;
+    xtm.tm_min	= syst->wMinute;
+    xtm.tm_sec	= syst->wSecond;
+    DOSFS_UnixTimeToFileTime(mktime(&xtm),ft);
+    return TRUE; 
+}
diff --git a/files/drive.c b/files/drive.c
index 9210de7..8a5bf5a 100644
--- a/files/drive.c
+++ b/files/drive.c
@@ -136,7 +136,10 @@
         {
             p = path + strlen(path) - 1;
             while ((p > path) && ((*p == '/') || (*p == '\\'))) *p-- = '\0';
-            drive->root     = xstrdup( path );
+            if (strlen(path))
+                drive->root = xstrdup( path );
+            else
+                drive->root = xstrdup( "/" );
             drive->dos_cwd  = xstrdup( "" );
             drive->unix_cwd = xstrdup( "" );
             drive->type     = DRIVE_GetDriveType( name );
@@ -681,6 +684,17 @@
  */
 BOOL32 SetCurrentDirectory( LPCSTR dir )
 {
+    if (dir[0] && (dir[1]==':'))
+    {
+        int drive = tolower( *dir ) - 'a';
+        if (!DRIVE_IsValid(drive))
+        {
+            DOS_ERROR( ER_InvalidDrive, EC_MediaError, SA_Abort, EL_Disk );
+            return 0;
+        }
+        dir += 2;
+    }
+    /* FIXME: what about empty strings? Add a \\ ? */
     return DRIVE_Chdir( DRIVE_GetCurrentDrive(), dir );
 }
 
diff --git a/files/file.c b/files/file.c
index d8b22b2..45ac9f0 100644
--- a/files/file.c
+++ b/files/file.c
@@ -366,8 +366,9 @@
             return HFILE_ERROR;
         }
     }
-    else if (!(unixName = DOSFS_GetUnixFileName( path, TRUE )))
-        return HFILE_ERROR;
+    else /* check for filename, don't check for last entry if creating */
+        if (!(unixName = DOSFS_GetUnixFileName( path, !(mode & O_CREAT) )))
+            return HFILE_ERROR;
 
     if (!(file = FILE_OpenUnixFile( unixName, mode ))) return HFILE_ERROR;
     if ((handle = FILE_AllocTaskHandle( file )) == HFILE_ERROR)
@@ -1406,3 +1407,71 @@
     }
     return file->type;
 }
+
+
+/***********************************************************************
+ *              GetFileTime   (KERNEL32.221)
+ */
+BOOL32 GetFileTime( HFILE hFile, FILETIME *lpCreationTime,
+                    FILETIME *lpLastAccessTime, FILETIME *lpLastWriteTime )
+{
+    DOS_FILE *file = FILE_GetFile(hFile);
+    struct stat stbuf;
+    
+    if (!file) {
+    	SetLastError( ERROR_INVALID_HANDLE );
+	return FILE_TYPE_UNKNOWN; /* FIXME: correct? */
+    }
+    dprintf_file(stddeb,"SetFileTime(%s,%p,%p,%p)\n",
+	file->unix_name,
+	lpCreationTime,
+	lpLastAccessTime,
+	lpLastWriteTime
+    );
+    if (-1==fstat(file->unix_handle,&stbuf)) {
+	FILE_SetDosError();
+	return FALSE;
+    }
+    if (lpLastWriteTime)
+    	DOSFS_UnixTimeToFileTime(stbuf.st_mtime,lpLastWriteTime);
+    if (lpCreationTime)
+	DOSFS_UnixTimeToFileTime(stbuf.st_ctime,lpCreationTime);
+    if (lpLastAccessTime)
+    	DOSFS_UnixTimeToFileTime(stbuf.st_atime,lpLastAccessTime);
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *              SetFileTime   (KERNEL32.493)
+ */
+BOOL32 SetFileTime( HFILE hFile, FILETIME *lpCreationTime,
+                    FILETIME *lpLastAccessTime, FILETIME *lpLastWriteTime )
+{
+    DOS_FILE *file = FILE_GetFile(hFile);
+    struct utimbuf utimbuf;
+    
+    if (!file) {
+    	SetLastError( ERROR_INVALID_HANDLE );
+    	return FILE_TYPE_UNKNOWN; /* FIXME: correct? */
+    }
+    dprintf_file(stddeb,"SetFileTime(%s,%p,%p,%p)\n",
+	file->unix_name,
+	lpCreationTime,
+	lpLastAccessTime,
+	lpLastWriteTime
+    );
+    if (lpLastAccessTime)
+	utimbuf.actime	= DOSFS_FileTimeToUnixTime(lpLastAccessTime);
+    else
+	utimbuf.actime	= 0; /* FIXME */
+    if (lpLastWriteTime)
+	utimbuf.modtime	= DOSFS_FileTimeToUnixTime(lpLastWriteTime);
+    else
+	utimbuf.modtime	= 0; /* FIXME */
+    if (-1==utime(file->unix_name,&utimbuf)) {
+	FILE_SetDosError();
+	return FALSE;
+    }
+    return TRUE;
+}
diff --git a/files/profile.c b/files/profile.c
index 4570b5e..ddb21ed 100644
--- a/files/profile.c
+++ b/files/profile.c
@@ -10,8 +10,8 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "dos_fs.h"
 #include "windows.h"
+#include "dos_fs.h"
 #include "xmalloc.h"
 #include "stddebug.h"
 #include "debug.h"
diff --git a/graphics/Makefile.in b/graphics/Makefile.in
index cc46354..9bb9535 100644
--- a/graphics/Makefile.in
+++ b/graphics/Makefile.in
@@ -6,6 +6,7 @@
 MODULE    = graphics
 
 C_SRCS = \
+	bitblt.c \
 	driver.c
 
 all: $(MODULE).o
diff --git a/graphics/bitblt.c b/graphics/bitblt.c
new file mode 100644
index 0000000..2acda69
--- /dev/null
+++ b/graphics/bitblt.c
@@ -0,0 +1,149 @@
+/*
+ * GDI bit-blit operations
+ *
+ * Copyright 1993, 1994  Alexandre Julliard
+ */
+
+#include "gdi.h"
+#include "stddebug.h"
+#include "debug.h"
+
+
+/***********************************************************************
+ *           PatBlt16    (GDI.29)
+ */
+BOOL16 PatBlt16( HDC16 hdc, INT16 left, INT16 top,
+                 INT16 width, INT16 height, DWORD rop)
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc || !dc->funcs->pPatBlt) return FALSE;
+
+    dprintf_bitblt( stddeb, "PatBlt16: %04x %d,%d %dx%d %06lx\n",
+                    hdc, left, top, width, height, rop );
+    return dc->funcs->pPatBlt( dc, left, top, width, height, rop );
+}
+
+
+/***********************************************************************
+ *           PatBlt32    (GDI32.260)
+ */
+BOOL32 PatBlt32( HDC32 hdc, INT32 left, INT32 top,
+                 INT32 width, INT32 height, DWORD rop)
+{
+    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
+    if (!dc || !dc->funcs->pPatBlt) return FALSE;
+
+    dprintf_bitblt( stddeb, "PatBlt32: %04x %d,%d %dx%d %06lx\n",
+                    hdc, left, top, width, height, rop );
+    return dc->funcs->pPatBlt( dc, left, top, width, height, rop );
+}
+
+
+/***********************************************************************
+ *           BitBlt16    (GDI.34)
+ */
+BOOL16 BitBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst, INT16 width,
+                 INT16 height, HDC16 hdcSrc, INT16 xSrc, INT16 ySrc, DWORD rop)
+{
+    DC *dcDst, *dcSrc;
+
+    if (!(dcDst = (DC *)GDI_GetObjPtr( hdcDst, DC_MAGIC ))) return FALSE;
+    if (!dcDst->funcs->pBitBlt) return FALSE;
+    dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
+
+    dprintf_bitblt(stddeb,
+                "BitBlt16: hdcSrc=%04x %d,%d %d bpp -> hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
+                hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->w.bitsPerPixel : 0,
+                hdcDst, xDst, yDst, width, height, dcDst->w.bitsPerPixel, rop);
+    return dcDst->funcs->pBitBlt( dcDst, xDst, yDst, width, height,
+                                  dcSrc, xSrc, ySrc, rop );
+}
+
+
+/***********************************************************************
+ *           BitBlt32    (GDI32.10)
+ */
+BOOL32 BitBlt32( HDC32 hdcDst, INT32 xDst, INT32 yDst, INT32 width,
+                 INT32 height, HDC32 hdcSrc, INT32 xSrc, INT32 ySrc, DWORD rop)
+{
+    DC *dcDst, *dcSrc;
+
+    if (!(dcDst = (DC *)GDI_GetObjPtr( hdcDst, DC_MAGIC ))) return FALSE;
+    if (!dcDst->funcs->pBitBlt) return FALSE;
+    dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
+
+    dprintf_bitblt(stddeb,
+                "BitBlt32: hdcSrc=%04x %d,%d %d bpp -> hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
+                hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->w.bitsPerPixel : 0,
+                hdcDst, xDst, yDst, width, height, dcDst->w.bitsPerPixel, rop);
+    return dcDst->funcs->pBitBlt( dcDst, xDst, yDst, width, height,
+                                  dcSrc, xSrc, ySrc, rop );
+}
+
+
+/***********************************************************************
+ *           StretchBlt16    (GDI.35)
+ */
+BOOL16 StretchBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst,
+                     INT16 widthDst, INT16 heightDst,
+                     HDC16 hdcSrc, INT16 xSrc, INT16 ySrc,
+                     INT16 widthSrc, INT16 heightSrc, DWORD rop )
+{
+    DC *dcDst, *dcSrc;
+
+    if (!(dcDst = (DC *) GDI_GetObjPtr( hdcDst, DC_MAGIC ))) return FALSE;
+    if (!dcDst->funcs->pStretchBlt) return FALSE;
+    dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
+    dprintf_bitblt(stddeb,
+        "StretchBlt16: %04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
+                   hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
+                   dcSrc ? dcSrc->w.bitsPerPixel : 0, hdcDst, xDst, yDst,
+                   widthDst, heightDst, dcDst->w.bitsPerPixel, rop );
+    return dcDst->funcs->pStretchBlt( dcDst, xDst, yDst, widthDst, heightDst,
+                                      dcSrc, xSrc, ySrc, widthSrc, heightSrc,
+                                      rop );
+}
+
+
+/***********************************************************************
+ *           StretchBlt32    (GDI32.350)
+ */
+BOOL32 StretchBlt32( HDC32 hdcDst, INT32 xDst, INT32 yDst,
+                     INT32 widthDst, INT32 heightDst,
+                     HDC32 hdcSrc, INT32 xSrc, INT32 ySrc,
+                     INT32 widthSrc, INT32 heightSrc, DWORD rop )
+{
+    DC *dcDst, *dcSrc;
+
+    if (!(dcDst = (DC *) GDI_GetObjPtr( hdcDst, DC_MAGIC ))) return FALSE;
+    if (!dcDst->funcs->pStretchBlt) return FALSE;
+    dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
+    dprintf_bitblt(stddeb,
+        "StretchBlt32: %04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
+                   hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
+                   dcSrc ? dcSrc->w.bitsPerPixel : 0, hdcDst, xDst, yDst,
+                   widthDst, heightDst, dcDst->w.bitsPerPixel, rop );
+    return dcDst->funcs->pStretchBlt( dcDst, xDst, yDst, widthDst, heightDst,
+                                      dcSrc, xSrc, ySrc, widthSrc, heightSrc,
+                                      rop );
+}
+
+
+/***********************************************************************
+ *           FastWindowFrame    (GDI.400)
+ */
+BOOL16 FastWindowFrame( HDC16 hdc, const RECT16 *rect,
+                        INT16 width, INT16 height, DWORD rop )
+{
+    HBRUSH32 hbrush = SelectObject32( hdc, GetStockObject32( GRAY_BRUSH ) );
+    PatBlt32( hdc, rect->left, rect->top,
+              rect->right - rect->left - width, height, rop );
+    PatBlt32( hdc, rect->left, rect->top + height, width,
+              rect->bottom - rect->top - height, rop );
+    PatBlt32( hdc, rect->left + width, rect->bottom,
+              rect->right - rect->left - width, -height, rop );
+    PatBlt32( hdc, rect->right, rect->top, -width, 
+              rect->bottom - rect->top - height, rop );
+    SelectObject32( hdc, hbrush );
+    return TRUE;
+}
diff --git a/graphics/metafiledrv/Makefile.in b/graphics/metafiledrv/Makefile.in
index 1e39e5b..02de44e 100644
--- a/graphics/metafiledrv/Makefile.in
+++ b/graphics/metafiledrv/Makefile.in
@@ -6,6 +6,7 @@
 MODULE    = metafiledrv
 
 C_SRCS = \
+	bitblt.c \
 	init.c
 
 all: $(MODULE).o
diff --git a/graphics/metafiledrv/bitblt.c b/graphics/metafiledrv/bitblt.c
new file mode 100644
index 0000000..34c6ad6
--- /dev/null
+++ b/graphics/metafiledrv/bitblt.c
@@ -0,0 +1,45 @@
+/*
+ * GDI bit-blit operations
+ *
+ * Copyright 1993, 1994  Alexandre Julliard
+ */
+
+#include "gdi.h"
+#include "metafile.h"
+#include "metafiledrv.h"
+
+/***********************************************************************
+ *           MFDRV_PatBlt
+ */
+BOOL32 MFDRV_PatBlt( DC *dc, INT32 left, INT32 top,
+                     INT32 width, INT32 height, DWORD rop )
+{
+    MF_MetaParam6( dc, META_PATBLT, left, top, width, height,
+                   HIWORD(rop), LOWORD(rop) );
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           MFDRV_BitBlt
+ */
+BOOL32 MFDRV_BitBlt( DC *dcDst, INT32 xDst, INT32 yDst,
+                      INT32 width, INT32 height, DC *dcSrc,
+                      INT32 xSrc, INT32 ySrc, DWORD rop )
+{
+    return MF_BitBlt( dcDst, xDst, yDst, width, height,
+                      dcSrc, xSrc, ySrc, rop );
+}
+
+
+/***********************************************************************
+ *           MFDRV_StretchBlt
+ */
+BOOL32 MFDRV_StretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
+                          INT32 widthDst, INT32 heightDst,
+                          DC *dcSrc, INT32 xSrc, INT32 ySrc,
+                          INT32 widthSrc, INT32 heightSrc, DWORD rop )
+{
+    return MF_StretchBlt( dcDst, xDst, yDst, widthDst, heightDst,
+                          dcSrc, xSrc, ySrc, widthSrc, heightSrc, rop );
+}
diff --git a/graphics/metafiledrv/init.c b/graphics/metafiledrv/init.c
index dc11829..e8ad11d 100644
--- a/graphics/metafiledrv/init.c
+++ b/graphics/metafiledrv/init.c
@@ -17,7 +17,7 @@
 static const DC_FUNCTIONS MFDRV_Funcs =
 {
     NULL,                            /* pArc */
-    NULL,                            /* pBitBlt */
+    MFDRV_BitBlt,                    /* pBitBlt */
     NULL,                            /* pChord */
     NULL,                            /* pCreateDC */
     MFDRV_DeleteDC,                  /* pDeleteDC */
@@ -42,7 +42,7 @@
     NULL,                            /* pOffsetViewportOrgEx */
     NULL,                            /* pOffsetWindowOrgEx */
     NULL,                            /* pPaintRgn */
-    NULL,                            /* pPatBlt */
+    MFDRV_PatBlt,                    /* pPatBlt */
     NULL,                            /* pPie */
     NULL,                            /* pPolyPolygon */
     NULL,                            /* pPolygon */
@@ -76,7 +76,7 @@
     NULL,                            /* pSetViewportOrgEx */
     NULL,                            /* pSetWindowExtEx */
     NULL,                            /* pSetWindowOrgEx */
-    NULL,                            /* pStretchBlt */
+    MFDRV_StretchBlt,                /* pStretchBlt */
     NULL,                            /* pStretchDIBits */
     NULL                             /* pTextOut */
 };
@@ -146,7 +146,6 @@
     METAFILEDRV_PDEVICE *physDev;
     HFILE hFile;
 
-    printf( "CreateMetafile16: '%s'\n", filename );
     dprintf_metafile( stddeb, "CreateMetaFile16: '%s'\n", filename );
 
     if (!(dc = MFDRV_AllocMetaFile())) return 0;
diff --git a/graphics/x11drv/Makefile.in b/graphics/x11drv/Makefile.in
index a197fd7..77883a2 100644
--- a/graphics/x11drv/Makefile.in
+++ b/graphics/x11drv/Makefile.in
@@ -6,6 +6,7 @@
 MODULE    = x11drv
 
 C_SRCS = \
+	bitblt.c \
 	clipping.c \
 	font.c \
 	init.c
diff --git a/objects/bitblt.c b/graphics/x11drv/bitblt.c
similarity index 90%
rename from objects/bitblt.c
rename to graphics/x11drv/bitblt.c
index 1bf8657..d037d13 100644
--- a/objects/bitblt.c
+++ b/graphics/x11drv/bitblt.c
@@ -14,8 +14,8 @@
 #include "dc.h"
 #include "metafile.h"
 #include "options.h"
+#include "x11drv.h"
 #include "stddebug.h"
-/* #define DEBUG_BITBLT */
 #include "debug.h"
 #include "xmalloc.h"
 
@@ -521,10 +521,10 @@
  * Stretch a row of pixels. Helper function for BITBLT_StretchImage.
  */
 static void BITBLT_StretchRow( int *rowSrc, int *rowDst,
-                               short startDst, short widthDst,
-                               int xinc, WORD mode )
+                               INT32 startDst, INT32 widthDst,
+                               INT32 xinc, WORD mode )
 {
-    register int xsrc = xinc * startDst;
+    register INT32 xsrc = xinc * startDst;
     rowDst += startDst;
     switch(mode)
     {
@@ -550,10 +550,10 @@
  * Shrink a row of pixels. Helper function for BITBLT_StretchImage.
  */
 static void BITBLT_ShrinkRow( int *rowSrc, int *rowDst,
-                              short startSrc, short widthSrc,
-                              int xinc, WORD mode )
+                              INT32 startSrc, INT32 widthSrc,
+                              INT32 xinc, WORD mode )
 {
-    register int xdst = xinc * startSrc;
+    register INT32 xdst = xinc * startSrc;
     rowSrc += startSrc;
     switch(mode)
     {
@@ -578,11 +578,11 @@
  *
  * Retrieve a row from an image. Helper function for BITBLT_StretchImage.
  */
-static void BITBLT_GetRow( XImage *image, int *pdata, short row,
-                           short start, short width, short depthDst,
-                           int fg, int bg, BOOL swap)
+static void BITBLT_GetRow( XImage *image, int *pdata, INT32 row,
+                           INT32 start, INT32 width, INT32 depthDst,
+                           int fg, int bg, BOOL32 swap)
 {
-    register short i;
+    register INT32 i;
 
     pdata += swap ? start+width-1 : start;
     if (image->depth == depthDst)  /* color -> color */
@@ -627,17 +627,18 @@
  *           BITBLT_StretchImage
  *
  * Stretch an X image.
+ * FIXME: does not work for full 32-bit coordinates.
  */
 static void BITBLT_StretchImage( XImage *srcImage, XImage *dstImage,
-                                 short widthSrc, short heightSrc,
-                                 short widthDst, short heightDst,
-                                 RECT16 *visRectSrc, RECT16 *visRectDst,
+                                 INT32 widthSrc, INT32 heightSrc,
+                                 INT32 widthDst, INT32 heightDst,
+                                 RECT32 *visRectSrc, RECT32 *visRectDst,
                                  int foreground, int background, WORD mode )
 {
     int *rowSrc, *rowDst, *pixel;
-    int xinc, yinc, ysrc, ydst;
-    register short x, y;
-    BOOL hstretch, vstretch, hswap, vswap;
+    INT32 xinc, yinc, ysrc, ydst;
+    register INT32 x, y;
+    BOOL32 hstretch, vstretch, hswap, vswap;
 
     hswap = ((int)widthSrc * widthDst) < 0;
     vswap = ((int)heightSrc * heightDst) < 0;
@@ -774,18 +775,18 @@
  */
 static void BITBLT_GetSrcAreaStretch( DC *dcSrc, DC *dcDst,
                                       Pixmap pixmap, GC gc,
-                                      short xSrc, short ySrc,
-                                      short widthSrc, short heightSrc,
-                                      short xDst, short yDst,
-                                      short widthDst, short heightDst,
-                                      RECT16 *visRectSrc, RECT16 *visRectDst )
+                                      INT32 xSrc, INT32 ySrc,
+                                      INT32 widthSrc, INT32 heightSrc,
+                                      INT32 xDst, INT32 yDst,
+                                      INT32 widthDst, INT32 heightDst,
+                                      RECT32 *visRectSrc, RECT32 *visRectDst )
 {
     XImage *imageSrc, *imageDst;
 
-    RECT16 rectSrc = *visRectSrc;
-    RECT16 rectDst = *visRectDst;
-    OffsetRect16( &rectSrc, -xSrc, -ySrc );
-    OffsetRect16( &rectDst, -xDst, -yDst );
+    RECT32 rectSrc = *visRectSrc;
+    RECT32 rectDst = *visRectDst;
+    OffsetRect32( &rectSrc, -xSrc, -ySrc );
+    OffsetRect32( &rectDst, -xDst, -yDst );
     /* FIXME: avoid BadMatch errors */
     imageSrc = XGetImage( display, dcSrc->u.x.drawable,
                           visRectSrc->left, visRectSrc->top,
@@ -813,13 +814,12 @@
  * pixels to Windows colors.
  */
 static void BITBLT_GetSrcArea( DC *dcSrc, DC *dcDst, Pixmap pixmap, GC gc,
-                               short xSrc, short ySrc,
-                               RECT16 *visRectSrc )
+                               INT32 xSrc, INT32 ySrc, RECT32 *visRectSrc )
 {
     XImage *imageSrc, *imageDst;
-    register short x, y;
-    short width  = visRectSrc->right - visRectSrc->left;
-    short height = visRectSrc->bottom - visRectSrc->top;
+    register INT32 x, y;
+    INT32 width  = visRectSrc->right - visRectSrc->left;
+    INT32 height = visRectSrc->bottom - visRectSrc->top;
 
     if (dcSrc->w.bitsPerPixel == dcDst->w.bitsPerPixel)
     {
@@ -899,10 +899,10 @@
  * Retrieve an area from the destination DC, mapping all the
  * pixels to Windows colors.
  */
-static void BITBLT_GetDstArea(DC *dc, Pixmap pixmap, GC gc, RECT16 *visRectDst)
+static void BITBLT_GetDstArea(DC *dc, Pixmap pixmap, GC gc, RECT32 *visRectDst)
 {
-    short width  = visRectDst->right - visRectDst->left;
-    short height = visRectDst->bottom - visRectDst->top;
+    INT32 width  = visRectDst->right - visRectDst->left;
+    INT32 height = visRectDst->bottom - visRectDst->top;
 
     if (!COLOR_PixelToPalette || (dc->w.bitsPerPixel == 1) ||
 	(COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) )
@@ -912,7 +912,7 @@
     }
     else
     {
-        register short x, y;
+        register INT32 x, y;
         XImage *image;
 
         if (dc->w.flags & DC_MEMORY)
@@ -942,10 +942,10 @@
  * Put an area back into the destination DC, mapping the pixel
  * colors to X pixels.
  */
-static void BITBLT_PutDstArea(DC *dc, Pixmap pixmap, GC gc, RECT16 *visRectDst)
+static void BITBLT_PutDstArea(DC *dc, Pixmap pixmap, GC gc, RECT32 *visRectDst)
 {
-    short width  = visRectDst->right - visRectDst->left;
-    short height = visRectDst->bottom - visRectDst->top;
+    INT32 width  = visRectDst->right - visRectDst->left;
+    INT32 height = visRectDst->bottom - visRectDst->top;
 
     /* !COLOR_PaletteToPixel is _NOT_ enough */
 
@@ -957,7 +957,7 @@
     }
     else
     {
-        register short x, y;
+        register INT32 x, y;
         XImage *image = XGetImage( display, pixmap, 0, 0, width, height,
                                    AllPlanes, ZPixmap );
         for (y = 0; y < height; y++)
@@ -979,13 +979,13 @@
  * Get the source and destination visible rectangles for StretchBlt().
  * Return FALSE if one of the rectangles is empty.
  */
-static BOOL BITBLT_GetVisRectangles( DC *dcDst, short xDst, short yDst,
-                                     short widthDst, short heightDst,
-                                     DC *dcSrc, short xSrc, short ySrc,
-                                     short widthSrc, short heightSrc,
-                                     RECT16 *visRectSrc, RECT16 *visRectDst )
+static BOOL32 BITBLT_GetVisRectangles( DC *dcDst, INT32 xDst, INT32 yDst,
+                                       INT32 widthDst, INT32 heightDst,
+                                       DC *dcSrc, INT32 xSrc, INT32 ySrc,
+                                       INT32 widthSrc, INT32 heightSrc,
+                                       RECT32 *visRectSrc, RECT32 *visRectDst )
 {
-    RECT16 tmpRect, clipRect;
+    RECT32 tmpRect, clipRect;
 
     if (widthSrc < 0)  { widthSrc = -widthSrc; xSrc -= widthSrc; }
     if (widthDst < 0)  { widthDst = -widthDst; xDst -= widthDst; }
@@ -994,28 +994,28 @@
 
       /* Get the destination visible rectangle */
 
-    SetRect16( &tmpRect, xDst, yDst, xDst + widthDst, yDst + heightDst );
-    GetRgnBox16( dcDst->w.hGCClipRgn, &clipRect );
-    OffsetRect16( &clipRect, dcDst->w.DCOrgX, dcDst->w.DCOrgY );
-    if (!IntersectRect16( visRectDst, &tmpRect, &clipRect )) return FALSE;
+    SetRect32( &tmpRect, xDst, yDst, xDst + widthDst, yDst + heightDst );
+    GetRgnBox32( dcDst->w.hGCClipRgn, &clipRect );
+    OffsetRect32( &clipRect, dcDst->w.DCOrgX, dcDst->w.DCOrgY );
+    if (!IntersectRect32( visRectDst, &tmpRect, &clipRect )) return FALSE;
 
       /* Get the source visible rectangle */
 
     if (!dcSrc) return TRUE;
-    SetRect16( &tmpRect, xSrc, ySrc, xSrc + widthSrc, ySrc + heightSrc );
+    SetRect32( &tmpRect, xSrc, ySrc, xSrc + widthSrc, ySrc + heightSrc );
     /* Apparently the clip region is only for output, so use hVisRgn here */
-    GetRgnBox16( dcSrc->w.hVisRgn, &clipRect );
-    OffsetRect16( &clipRect, dcSrc->w.DCOrgX, dcSrc->w.DCOrgY );
-    if (!IntersectRect16( visRectSrc, &tmpRect, &clipRect )) return FALSE;
+    GetRgnBox32( dcSrc->w.hVisRgn, &clipRect );
+    OffsetRect32( &clipRect, dcSrc->w.DCOrgX, dcSrc->w.DCOrgY );
+    if (!IntersectRect32( visRectSrc, &tmpRect, &clipRect )) return FALSE;
 
       /* Intersect the rectangles */
 
     if ((widthSrc == widthDst) && (heightSrc == heightDst)) /* no stretching */
     {
-        OffsetRect16( visRectSrc, xDst - xSrc, yDst - ySrc );
-        if (!IntersectRect16( &tmpRect, visRectSrc, visRectDst )) return FALSE;
+        OffsetRect32( visRectSrc, xDst - xSrc, yDst - ySrc );
+        if (!IntersectRect32( &tmpRect, visRectSrc, visRectDst )) return FALSE;
         *visRectSrc = *visRectDst = tmpRect;
-        OffsetRect16( visRectSrc, xSrc - xDst, ySrc - yDst );
+        OffsetRect32( visRectSrc, xSrc - xDst, ySrc - yDst );
     }
     else  /* stretching */
     {
@@ -1025,7 +1025,7 @@
                             ((visRectSrc->right-xSrc) * widthDst) / widthSrc;
         visRectSrc->bottom = yDst +
                          ((visRectSrc->bottom-ySrc) * heightDst) / heightSrc;
-        if (!IntersectRect16( &tmpRect, visRectSrc, visRectDst )) return FALSE;
+        if (!IntersectRect32( &tmpRect, visRectSrc, visRectDst )) return FALSE;
         *visRectSrc = *visRectDst = tmpRect;
         visRectSrc->left = xSrc + (visRectSrc->left-xDst)*widthSrc/widthDst;
         visRectSrc->top = ySrc + (visRectSrc->top-yDst)*heightSrc/heightDst;
@@ -1033,7 +1033,7 @@
                             ((visRectSrc->right-xDst) * widthSrc) / widthDst;
         visRectSrc->bottom = ySrc +
                          ((visRectSrc->bottom-yDst) * heightSrc) / heightDst;
-        if (IsRectEmpty16( visRectSrc )) return FALSE;
+        if (IsRectEmpty32( visRectSrc )) return FALSE;
     }
     return TRUE;
 }
@@ -1044,14 +1044,14 @@
  *
  * Implementation of PatBlt(), BitBlt() and StretchBlt().
  */
-BOOL BITBLT_InternalStretchBlt( DC *dcDst, short xDst, short yDst,
-                                short widthDst, short heightDst,
-                                DC *dcSrc, short xSrc, short ySrc,
-                                short widthSrc, short heightSrc, DWORD rop )
+BOOL32 BITBLT_InternalStretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
+                                  INT32 widthDst, INT32 heightDst,
+                                  DC *dcSrc, INT32 xSrc, INT32 ySrc,
+                                  INT32 widthSrc, INT32 heightSrc, DWORD rop )
 {
-    BOOL usePat, useSrc, useDst, destUsed, fStretch, fNullBrush;
-    RECT16 visRectDst, visRectSrc;
-    short width, height;
+    BOOL32 usePat, useSrc, useDst, destUsed, fStretch, fNullBrush;
+    RECT32 visRectDst, visRectSrc;
+    INT32 width, height;
     const BYTE *opcode;
     Pixmap pixmaps[3] = { 0, 0, 0 };  /* pixmaps for DST, SRC, TMP */
     GC tmpGC = 0;
@@ -1285,24 +1285,11 @@
 
 
 /***********************************************************************
- *           PatBlt    (GDI.29)
+ *           X11DRV_PatBlt
  */
-BOOL PatBlt( HDC16 hdc, short left, short top,
-	     short width, short height, DWORD rop)
+BOOL32 X11DRV_PatBlt( DC *dc, INT32 left, INT32 top,
+                      INT32 width, INT32 height, DWORD rop )
 {
-    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
-    if (!dc) 
-    {
-	dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
-	if (!dc) return FALSE;
-	MF_MetaParam6(dc, META_PATBLT, left, top, width, height,
-		      HIWORD(rop), LOWORD(rop));
-	return TRUE;
-    }
-
-    dprintf_bitblt(stddeb, "PatBlt: %04x %d,%d %dx%d %06lx\n",
-                   hdc, left, top, width, height, rop );
-
     return CallTo32_LargeStack( (int(*)())BITBLT_InternalStretchBlt, 11,
                                  dc, left, top, width, height,
                                  NULL, 0, 0, 0, 0, rop );
@@ -1310,27 +1297,12 @@
 
 
 /***********************************************************************
- *           BitBlt    (GDI.34)
+ *           X11DRV_BitBlt
  */
-BOOL BitBlt( HDC16 hdcDst, INT xDst, INT yDst, INT width, INT height,
-	     HDC16 hdcSrc, INT xSrc, INT ySrc, DWORD rop )
+BOOL32 X11DRV_BitBlt( DC *dcDst, INT32 xDst, INT32 yDst,
+                      INT32 width, INT32 height, DC *dcSrc,
+                      INT32 xSrc, INT32 ySrc, DWORD rop )
 {
-    DC *dcDst, *dcSrc;
-
-    if (!(dcDst = (DC *)GDI_GetObjPtr( hdcDst, DC_MAGIC )))
-    {
-        dcDst = (DC *)GDI_GetObjPtr( hdcDst, METAFILE_DC_MAGIC );
-        if (!dcDst) return FALSE;
-        return MF_BitBlt( dcDst, xDst, yDst, width, height,
-                          hdcSrc, xSrc, ySrc, rop );
-    }
-    dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
-
-    dprintf_bitblt(stddeb,
-                "BitBlt: hdcSrc=%04x %d,%d %d bpp -> hdcDest=%04x %d,%d %dx%dx%d rop=%06lx\n",
-                hdcSrc, xSrc, ySrc, dcSrc ? dcSrc->w.bitsPerPixel : 0,
-                hdcDst, xDst, yDst, width, height, dcDst->w.bitsPerPixel, rop);
-
     return CallTo32_LargeStack( (int(*)())BITBLT_InternalStretchBlt, 11,
                                 dcDst, xDst, yDst, width, height,
                                 dcSrc, xSrc, ySrc, width, height, rop );
@@ -1338,39 +1310,14 @@
 
 
 /***********************************************************************
- *           StretchBlt    (GDI.35)
+ *           X11DRV_StretchBlt
  */
-BOOL StretchBlt( HDC16 hdcDst, short xDst, short yDst,
-                 short widthDst, short heightDst,
-                 HDC16 hdcSrc, short xSrc, short ySrc,
-                 short widthSrc, short heightSrc, DWORD rop )
+BOOL32 X11DRV_StretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
+                          INT32 widthDst, INT32 heightDst,
+                          DC *dcSrc, INT32 xSrc, INT32 ySrc,
+                          INT32 widthSrc, INT32 heightSrc, DWORD rop )
 {
-    DC *dcDst, *dcSrc;
-
-    if (!(dcDst = (DC *) GDI_GetObjPtr( hdcDst, DC_MAGIC )))
-    {
-	if (!(dcDst = (DC *)GDI_GetObjPtr( hdcDst, METAFILE_DC_MAGIC )))
-            return FALSE;
-        return MF_StretchBlt( dcDst, xDst, yDst, widthDst, heightDst,
-                              hdcSrc, xSrc, ySrc, widthSrc, heightSrc, rop );
-    }
-
-    dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
-    dprintf_bitblt(stddeb,
-          "StretchBlt: %04x %d,%d %dx%dx%d -> %04x %d,%d %dx%dx%d rop=%06lx\n",
-                   hdcSrc, xSrc, ySrc, widthSrc, heightSrc,
-                   dcSrc ? dcSrc->w.bitsPerPixel : 0, hdcDst, xDst, yDst,
-                   widthDst, heightDst, dcDst->w.bitsPerPixel, rop );
-
     return CallTo32_LargeStack( (int(*)())BITBLT_InternalStretchBlt, 11,
                                 dcDst, xDst, yDst, widthDst, heightDst,
                                 dcSrc, xSrc, ySrc, widthSrc, heightSrc, rop );
 }
-/***********************************************************************
- *           FastWindowFrame    (GDI.400)
- */
-WORD
-FastWindowFrame(WORD x1,DWORD x2,WORD x3,WORD x4,DWORD x5) {
-	dprintf_gdi(stdnimp,"FastWindowFrame (%04x, %08lx, %04x, %04x, %08lx) // unimplemented!\n",x1,x2,x3,x4,x5);
-	return 0xFFFF; /* failed? */
-}
diff --git a/graphics/x11drv/init.c b/graphics/x11drv/init.c
index 5d43e8d..4841c2b 100644
--- a/graphics/x11drv/init.c
+++ b/graphics/x11drv/init.c
@@ -17,7 +17,7 @@
 static const DC_FUNCTIONS X11DRV_Funcs =
 {
     NULL,                            /* pArc */
-    NULL,                            /* pBitBlt */
+    X11DRV_BitBlt,                   /* pBitBlt */
     NULL,                            /* pChord */
     X11DRV_CreateDC,                 /* pCreateDC */
     X11DRV_DeleteDC,                 /* pDeleteDC */
@@ -42,7 +42,7 @@
     NULL,                            /* pOffsetViewportOrgEx */
     NULL,                            /* pOffsetWindowOrgEx */
     NULL,                            /* pPaintRgn */
-    NULL,                            /* pPatBlt */
+    X11DRV_PatBlt,                   /* pPatBlt */
     NULL,                            /* pPie */
     NULL,                            /* pPolyPolygon */
     NULL,                            /* pPolygon */
@@ -76,7 +76,7 @@
     NULL,                            /* pSetViewportOrgEx */
     NULL,                            /* pSetWindowExtEx */
     NULL,                            /* pSetWindowOrgEx */
-    NULL,                            /* pStretchBlt */
+    X11DRV_StretchBlt,               /* pStretchBlt */
     NULL,                            /* pStretchDIBits */
     NULL                             /* pTextOut */
 };
diff --git a/if1632/Makefile.in b/if1632/Makefile.in
index 62c579b..9efa8c9 100644
--- a/if1632/Makefile.in
+++ b/if1632/Makefile.in
@@ -45,6 +45,7 @@
 	version.spec \
 	w32sys.spec \
 	win87em.spec \
+	wing.spec \
 	winmm.spec \
 	winsock.spec \
 	winspool.spec \
diff --git a/if1632/crtdll.spec b/if1632/crtdll.spec
index bd07234..6e15693 100644
--- a/if1632/crtdll.spec
+++ b/if1632/crtdll.spec
@@ -287,7 +287,7 @@
 282 cdecl _strcmpi(ptr ptr) lstrcmpi32A
 283 stub _strdate
 284 stub _strdec
-285 stub _strdup
+285 cdecl _strdup(ptr) CRTDLL__strdup
 286 stub _strerror
 287 cdecl _stricmp(ptr ptr) lstrcmpi32A
 288 stub _stricoll
@@ -364,7 +364,7 @@
 359 cdecl exit(long) CRTDLL_exit
 360 cdecl exp(long) CRTDLL_exp
 361 cdecl fabs(long) CRTDLL_fabs
-362 stub fclose
+362 cdecl fclose(ptr) CRTDLL_fclose
 363 stub feof
 364 stub ferror
 365 cdecl fflush(ptr) CRTDLL_fflush
@@ -433,11 +433,11 @@
 428 stub mblen
 429 stub mbstowcs
 430 stub mbtowc
-431 stub memchr
-432 stub memcmp
-433 stub memcpy
-434 stub memmove
-435 stub memset
+431 cdecl memchr(ptr long long) memchr
+432 cdecl memcmp(ptr ptr long) memcmp
+433 cdecl memcpy(ptr ptr long) memcpy
+434 cdecl memmove(ptr ptr long) memmove
+435 cdecl memset(ptr long long) memset 
 436 stub mktime
 437 stub modf
 438 stub perror
@@ -460,16 +460,16 @@
 455 stub signal
 456 cdecl sin(long) CRTDLL_sin
 457 cdecl sinh(long) CRTDLL_sinh
-458 stub sprintf
+458 cdecl sprintf() CRTDLL_sprintf
 459 cdecl sqrt(long) CRTDLL_sqrt
 460 cdecl srand(long) CRTDLL_srand
 461 stub sscanf
 462 cdecl strcat(ptr ptr) lstrcat32A
-463 stub strchr
+463 cdecl strchr(ptr long) strchr
 464 cdecl strcmp(ptr ptr) lstrcmp32A
 465 stub strcoll
 466 cdecl strcpy(ptr ptr) lstrcpy32A
-467 stub strcspn
+467 cdecl strcspn(ptr ptr) strcspn
 468 stub strerror
 469 stub strftime
 470 cdecl strlen(ptr) lstrlen32A
@@ -478,11 +478,11 @@
 473 cdecl strncpy(ptr ptr long) lstrcpyn32A
 474 stub strpbrk
 475 stub strrchr
-476 stub strspn
-477 stub strstr
+476 cdecl strspn(ptr ptr) strspn
+477 cdecl strstr(ptr ptr) strstr
 478 stub strtod
-479 stub strtok
-480 stub strtol
+479 cdecl strtok(ptr ptr) strtok
+480 cdecl strtol(ptr ptr long) strtol
 481 cdecl strtoul(ptr ptr long) strtoul
 482 stub strxfrm
 483 stub swprintf
diff --git a/if1632/gdi.spec b/if1632/gdi.spec
index 2f0433c..4a8e1b5 100644
--- a/if1632/gdi.spec
+++ b/if1632/gdi.spec
@@ -33,15 +33,15 @@
 27  pascal16 Rectangle(word s_word s_word s_word s_word) Rectangle16
 28  pascal16 RoundRect(word s_word s_word s_word s_word s_word s_word)
              RoundRect16
-29  pascal16 PatBlt(word s_word s_word s_word s_word long) PatBlt
+29  pascal16 PatBlt(word s_word s_word s_word s_word long) PatBlt16
 30  pascal16 SaveDC(word) SaveDC
 31  pascal   SetPixel(word s_word s_word long) SetPixel16
 32  pascal16 OffsetClipRgn(word s_word s_word) OffsetClipRgn16
 33  pascal16 TextOut(word s_word s_word ptr word) TextOut16
 34  pascal16 BitBlt( word s_word s_word s_word s_word word s_word s_word long)
-             BitBlt
+             BitBlt16
 35  pascal16 StretchBlt(word s_word s_word s_word s_word word s_word s_word
-                        s_word s_word long) StretchBlt
+                        s_word s_word long) StretchBlt16
 36  pascal16 Polygon (word ptr word) Polygon16
 37  pascal16 Polyline (word ptr word) Polyline16
 38  pascal Escape(word word word segptr segptr) Escape
@@ -262,7 +262,7 @@
 380 stub ENDPAGE
 381 stub SETABORTPROC
 382 stub ABORTDOC
-400 pascal16 FastWindowFrame(word long word word long) FastWindowFrame
+400 pascal16 FastWindowFrame(word ptr s_word s_word long) FastWindowFrame
 401 stub GDIMOVEBITMAP
 403 stub GDIINIT2
 404 stub GetTTGlyphIndexMap
diff --git a/if1632/gdi32.spec b/if1632/gdi32.spec
index aad949c..6c6853e 100644
--- a/if1632/gdi32.spec
+++ b/if1632/gdi32.spec
@@ -12,7 +12,7 @@
 0007 stdcall Arc(long long long long long long long long long) Arc32
 0008 stub ArcTo
 0009 stub BeginPath
-0010 stdcall BitBlt(long long long long long long long long long) BitBlt
+0010 stdcall BitBlt(long long long long long long long long long) BitBlt32
 0011 stub CancelDC
 0012 stub CheckColorsInGamut
 0013 stub ChoosePixelFormat
@@ -85,10 +85,10 @@
 0077 stub EndPage
 0078 stub EndPath
 0079 stub EnumEnhMetaFile
-0080 stub EnumFontFamiliesA
+0080 stdcall EnumFontFamiliesA(long ptr ptr long) THUNK_EnumFontFamilies32A
 0081 stub EnumFontFamiliesExA
 0082 stub EnumFontFamiliesExW
-0083 stub EnumFontFamiliesW
+0083 stdcall EnumFontFamiliesW(long ptr ptr long) THUNK_EnumFontFamilies32W
 0084 stub EnumFontsA
 0085 stub EnumFontsW
 0086 stub EnumICMProfilesA
@@ -265,7 +265,7 @@
 0257 stdcall OffsetViewportOrgEx(long long long ptr) OffsetViewportOrgEx32
 0258 stdcall OffsetWindowOrgEx(long long long ptr) OffsetWindowOrgEx32
 0259 stdcall PaintRgn(long long) PaintRgn32
-0260 stdcall PatBlt(long long long long long long) PatBlt
+0260 stdcall PatBlt(long long long long long long) PatBlt32
 0261 stub PathToRegion
 0262 stdcall Pie(long long long long long long long long long) Pie32
 0263 stub PlayEnhMetaFile
@@ -356,7 +356,8 @@
 0347 stub StartDocA
 0348 stub StartDocW
 0349 stub StartPage
-0350 stdcall StretchBlt(long long long long long long long long long long long) StretchBlt
+0350 stdcall StretchBlt(long long long long long long long long long long long)
+             StretchBlt32
 0351 stdcall StretchDIBits(long long long long long long long
                                long long long long long long) StretchDIBits
 0352 stub StrokeAndFillPath
diff --git a/if1632/kernel32.spec b/if1632/kernel32.spec
index ca3fc9b..ecf6020 100644
--- a/if1632/kernel32.spec
+++ b/if1632/kernel32.spec
@@ -78,7 +78,7 @@
 0073 stub DeviceIoControl
 0074 stub DisableThreadLibraryCalls
 0075 stub DisconnectNamedPipe
-0076 stub DosDateTimeToFileTime
+0076 stdcall DosDateTimeToFileTime(long long ptr) DosDateTimeToFileTime
 0077 stub DuplicateConsoleHandle
 0078 	stdcall DuplicateHandle(long long long ptr long long long) DuplicateHandle
 0079 stub EndUpdateResourceA
@@ -94,8 +94,8 @@
 0089 stub EnumResourceNamesW
 0090 stub EnumResourceTypesA
 0091 stub EnumResourceTypesW
-0092 stub EnumSystemCodePagesA
-0093 stub EnumSystemCodePagesW
+0092 stdcall EnumSystemCodePagesA(ptr long) THUNK_EnumSystemCodePages32A
+0093 stdcall EnumSystemCodePagesW(ptr long) THUNK_EnumSystemCodePages32W
 0094 stub EnumSystemLocalesA
 0095 stub EnumSystemLocalesW
 0096 stub EnumTimeFormatsA
@@ -113,9 +113,9 @@
 0108 stub FatalAppExitA
 0109 stub FatalAppExitW
 0110 stub FatalExit
-0111 stub FileTimeToDosDateTime
-0112 stub FileTimeToLocalFileTime
-0113 stub FileTimeToSystemTime
+0111 stdcall FileTimeToDosDateTime(ptr ptr ptr) FileTimeToDosDateTime
+0112 stdcall FileTimeToLocalFileTime(ptr ptr) FileTimeToLocalFileTime
+0113 stdcall FileTimeToSystemTime(ptr ptr) FileTimeToSystemTime
 0114 stub FillConsoleOutputAttribute
 0115 stub FillConsoleOutputCharacterA
 0116 stub FillConsoleOutputCharacterW
@@ -222,22 +222,22 @@
 0217 stdcall GetFileAttributesA(ptr) GetFileAttributes32A
 0218 stdcall GetFileAttributesW(ptr) GetFileAttributes32W
 0219 stdcall GetFileInformationByHandle(long ptr) GetFileInformationByHandle
-0220 stub GetFileSize
-0221 stub GetFileTime
-0222    stdcall GetFileType(long) GetFileType
+0220 stdcall GetFileSize(long ptr ptr) GetFileSize
+0221 stdcall GetFileTime(long ptr ptr ptr) GetFileTime
+0222 stdcall GetFileType(long) GetFileType
 0223 stdcall GetFullPathNameA(ptr long ptr ptr) GetFullPathName32A
 0224 stub GetFullPathNameW
 0225 stub GetHandleInformation
 0226 stdcall GetLargestConsoleWindowSize(long) GetLargestConsoleWindowSize
-0227    stdcall GetLastError() GetLastError
-0228    stdcall GetLocalTime(ptr) GetLocalTime
+0227 stdcall GetLastError() GetLastError
+0228 stdcall GetLocalTime(ptr) GetLocalTime
 0229 stdcall GetLocaleInfoA(long long ptr long) GetLocaleInfoA
 0230 stdcall GetLocaleInfoW(long long ptr long) GetLocaleInfo32W
 0231 stdcall GetLogicalDriveStringsA(long ptr) GetLogicalDriveStrings32A
 0232 stdcall GetLogicalDriveStringsW(long ptr) GetLogicalDriveStrings32W
 0233 stdcall GetLogicalDrives() GetLogicalDrives
 0234 stub GetMailslotInfo
-0235	stdcall GetModuleFileNameA(long ptr long) GetModuleFileNameA
+0235 stdcall GetModuleFileNameA(long ptr long) GetModuleFileName
 0236 stub GetModuleFileNameW
 0237	stdcall GetModuleHandleA(ptr)	WIN32_GetModuleHandle
 0238 stub GetModuleHandleW
@@ -286,7 +286,7 @@
 0281 stdcall GetSystemDefaultLangID() GetSystemDefaultLangID
 0282 stdcall GetSystemDirectoryA(ptr long) GetSystemDirectory32A
 0283 stdcall GetSystemDirectoryW(ptr long) GetSystemDirectory32W
-0284 stub GetSystemInfo
+0284 stdcall GetSystemInfo(ptr) GetSystemInfo
 0285 	stdcall GetSystemTime(ptr) GetSystemTime
 0286 stub GetSystemTimeAdjustment
 0287 stub GetTapeParameters
@@ -375,7 +375,7 @@
 0370 stdcall LoadResource(long long) LoadResource32
 0371 stdcall LocalAlloc(long long) LocalAlloc32
 0372 stdcall LocalCompact(long) LocalCompact32
-0373 stub LocalFileTimeToFileTime
+0373 stdcall LocalFileTimeToFileTime(ptr ptr) LocalFileTimeToFileTime
 0374 stdcall LocalFlags(long) LocalFlags32
 0375 stdcall LocalFree(long) LocalFree32
 0376 stdcall LocalHandle(ptr) LocalHandle32
@@ -387,7 +387,7 @@
 0382 stub LockFile
 0383 stub LockFileEx
 0384 stdcall LockResource(long) LockResource32
-0385 stub MapViewOfFile
+0385 stdcall MapViewOfFile(long long long long long) MapViewOfFile
 0386 stdcall MapViewOfFileEx(long long long long long long) MapViewOfFileEx
 0387 stdcall MoveFileA(ptr ptr) MoveFile32A
 0388 stub MoveFileExA
@@ -494,8 +494,8 @@
 0489 stub SetFileApisToOEM
 0490 stdcall SetFileAttributesA(ptr long) SetFileAttributes32A
 0491 stdcall SetFileAttributesW(ptr long) SetFileAttributes32W
-0492    stdcall SetFilePointer(long long ptr long) SetFilePointer
-0493 stub SetFileTime
+0492 stdcall SetFilePointer(long long ptr long) SetFilePointer
+0493 stdcall SetFileTime(long ptr ptr ptr) SetFileTime
 0494 stdcall SetHandleCount(long) SetHandleCount32
 0495 stub SetHandleInformation
 0496 stub SetLastConsoleEventActive
@@ -528,7 +528,7 @@
 0523 	stdcall Sleep(long) Sleep
 0524 stub SleepEx
 0525 stub SuspendThread
-0526 stub SystemTimeToFileTime
+0526 stdcall SystemTimeToFileTime(ptr ptr) SystemTimeToFileTime
 0527 stub SystemTimeToTzSpecificLocalTime
 0528 stub TerminateProcess
 0529 stub TerminateThread
@@ -568,7 +568,7 @@
 0563 stub WaitNamedPipeA
 0564 stub WaitNamedPipeW
 0565 stdcall WideCharToMultiByte(long long ptr long ptr long ptr ptr)	WideCharToMultiByte
-0566 stub WinExec
+0566 stdcall WinExec(ptr long) WinExec
 0567 stub WriteConsoleA
 0568 stub WriteConsoleInputA
 0569 stub WriteConsoleInputVDMA
@@ -636,7 +636,7 @@
 0630    stdcall SetSystemPowerState(long long) SetSystemPowerState
 0631 stub WritePrivateProfileStructA
 0632 stub WritePrivateProfileStructW
-0633 stub MakeCriticalSectionGlobal
+0633 stdcall MakeCriticalSectionGlobal(ptr) MakeCriticalSectionGlobal
 #extra late additions
 0634 stdcall ThunkConnect32(ptr ptr ptr ptr ptr ptr) ThunkConnect32
 0636 stub SUnMapLS
diff --git a/if1632/ole32.spec b/if1632/ole32.spec
index cf93117..d6ff57b 100644
--- a/if1632/ole32.spec
+++ b/if1632/ole32.spec
@@ -109,7 +109,7 @@
 104 stub OleGetClipboard
 105 stub OleGetIconOfClass
 106 stub OleGetIconOfFile
-107 stub OleInitialize
+107 return OleInitialize 4 0
 108 stub OleInitializeWOW
 109 stub OleIsCurrentClipboard
 110 stub OleIsRunning
diff --git a/if1632/thunk.c b/if1632/thunk.c
index 8441542..348606f 100644
--- a/if1632/thunk.c
+++ b/if1632/thunk.c
@@ -139,7 +139,29 @@
                                 FONTENUMPROC16 func, LPARAM lParam )
 {
     DECL_THUNK( thunk, func, CallTo16_word_llwl );
-    return EnumFontFamilies( hdc, lpszFamily, (FONTENUMPROC16)&thunk, lParam );
+    return EnumFontFamilies16(hdc, lpszFamily, (FONTENUMPROC16)&thunk, lParam);
+}
+
+
+/*************************************************************************
+ *           THUNK_EnumFontFamilies32A   (GDI32.80)
+ */
+INT32 THUNK_EnumFontFamilies32A( HDC32 hdc, LPCSTR lpszFamily,
+                                 FONTENUMPROC32A func, LPARAM lParam )
+{
+    DECL_THUNK( thunk, func, CallTo32_4 );
+    return EnumFontFamilies32A(hdc,lpszFamily,(FONTENUMPROC32A)&thunk,lParam);
+}
+
+
+/*************************************************************************
+ *           THUNK_EnumFontFamilies32W   (GDI32.83)
+ */
+INT32 THUNK_EnumFontFamilies32W( HDC32 hdc, LPCWSTR lpszFamily,
+                                 FONTENUMPROC32W func, LPARAM lParam )
+{
+    DECL_THUNK( thunk, func, CallTo32_4 );
+    return EnumFontFamilies32W(hdc,lpszFamily,(FONTENUMPROC32W)&thunk,lParam);
 }
 
 
@@ -280,6 +302,26 @@
 
 
 /***********************************************************************
+ *           THUNK_EnumSystemCodePages32A	(KERNEL32.92)
+ */
+BOOL32 THUNK_EnumSystemCodePages32A( CODEPAGE_ENUMPROC32A func, DWORD flags )
+{
+    DECL_THUNK( thunk, func, CallTo32_1 );
+    return EnumSystemCodePages32A( (CODEPAGE_ENUMPROC32A)&thunk, flags );
+}
+
+
+/***********************************************************************
+ *           THUNK_EnumSystemCodePages32W	(KERNEL32.93)
+ */
+BOOL32 THUNK_EnumSystemCodePages32W( CODEPAGE_ENUMPROC32W func, DWORD flags )
+{
+    DECL_THUNK( thunk, func, CallTo32_1 );
+    return EnumSystemCodePages32W( (CODEPAGE_ENUMPROC32W)&thunk, flags );
+}
+
+
+/***********************************************************************
  *           THUNK_GrayString16   (USER.185)
  */
 BOOL16 THUNK_GrayString16( HDC16 hdc, HBRUSH16 hbr, GRAYSTRINGPROC16 func,
diff --git a/if1632/user.spec b/if1632/user.spec
index 77c3c62..2ca9abf 100644
--- a/if1632/user.spec
+++ b/if1632/user.spec
@@ -61,7 +61,7 @@
 58  pascal16 GetClassName(word ptr word) GetClassName16
 59  pascal16 SetActiveWindow(word) SetActiveWindow
 60  pascal16 GetActiveWindow() GetActiveWindow
-61  pascal16 ScrollWindow(word s_word s_word ptr ptr) ScrollWindow
+61  pascal16 ScrollWindow(word s_word s_word ptr ptr) ScrollWindow16
 62  pascal16 SetScrollPos(word word s_word word) SetScrollPos16
 63  pascal16 GetScrollPos(word word) GetScrollPos16
 64  pascal16 SetScrollRange(word word s_word s_word word) SetScrollRange16
@@ -221,7 +221,7 @@
 218 pascal16 DialogBoxIndirect(word word word segptr) DialogBoxIndirect16
 219 pascal16 CreateDialogIndirect(word ptr word segptr) CreateDialogIndirect16
 220 pascal16 LoadMenuIndirect(ptr) LoadMenuIndirect16
-221 pascal16 ScrollDC(word s_word s_word ptr ptr word ptr) ScrollDC
+221 pascal16 ScrollDC(word s_word s_word ptr ptr word ptr) ScrollDC16
 222 pascal16 GetKeyboardState(ptr) GetKeyboardState
 223 pascal16 SetKeyboardState(ptr) SetKeyboardState
 224 pascal16 GetWindowTask(word) GetWindowTask16
@@ -305,8 +305,7 @@
 308 pascal   DefDlgProc(word word word long) DefDlgProc16
 309 pascal16 GetClipCursor(ptr) GetClipCursor16
 314 stub SignalProc
-319 pascal16 ScrollWindowEx(word s_word s_word ptr ptr word ptr word)
-             ScrollWindowEx
+319 pascal16 ScrollWindowEx(word s_word s_word ptr ptr word ptr word) ScrollWindowEx16
 320 stub SysErrorBox
 321 stub SetEventHook
 322 stub WinOldAppHackOMatic
@@ -374,8 +373,8 @@
 418 pascal16 SetMenuItemBitmaps(word word word word word) SetMenuItemBitmaps
 420 pascal16 wsprintf() WIN16_wsprintf16
 421 pascal16 wvsprintf(ptr ptr ptr) wvsprintf16
-422 stub DlgDirSelectEx
-423 stub DlgDirSelectComboBoxEx
+422 pascal16 DlgDirSelectEx(word ptr word word) DlgDirSelectEx16
+423 pascal16 DlgDirSelectComboBoxEx(word ptr word word) DlgDirSelectComboBoxEx16
 427 pascal16 FindWindowEx(word word segptr ptr) FindWindowEx16
 428 stub TileWindows
 429 stub CascadeWindows
diff --git a/if1632/user32.spec b/if1632/user32.spec
index 0c12313..7a484ba 100644
--- a/if1632/user32.spec
+++ b/if1632/user32.spec
@@ -150,10 +150,10 @@
 0143 stdcall DlgDirListComboBoxA(long ptr long long long) DlgDirListComboBox32A
 0144 stdcall DlgDirListComboBoxW(long ptr long long long) DlgDirListComboBox32W
 0145 stub DlgDirListW
-0146 stub DlgDirSelectComboBoxExA
-0147 stub DlgDirSelectComboBoxExW
-0148 stub DlgDirSelectExA
-0149 stub DlgDirSelectExW
+0146 stdcall DlgDirSelectComboBoxExA(long ptr long long) DlgDirSelectComboBoxEx32A
+0147 stdcall DlgDirSelectComboBoxExW(long ptr long long) DlgDirSelectComboBoxEx32W
+0148 stdcall DlgDirSelectExA(long ptr long long) DlgDirSelectEx32A
+0149 stdcall DlgDirSelectExW(long ptr long long) DlgDirSelectEx32W
 0150 stub DragDetect
 0151 stub DragObject
 0152 stub DrawAnimatedRects
@@ -162,7 +162,7 @@
 0155 stdcall DrawFocusRect(long ptr) DrawFocusRect32
 0156 stub DrawFrame
 0157 stdcall DrawFrameControl(long ptr long long) DrawFrameControl32
-0158 stub DrawIcon
+0158 stdcall DrawIcon(long long long long) DrawIcon
 0159 stub DrawIconEx
 0160 stdcall DrawMenuBar(long) DrawMenuBar
 0161 stub DrawStateA
@@ -230,7 +230,7 @@
 0223 stub GetClipboardFormatNameW
 0224 stub GetClipboardOwner
 0225 stdcall GetClipboardViewer(long) GetClipboardViewer
-0226 stub GetCursor
+0226 stdcall GetCursor() GetCursor
 0227 stub GetCursorInfo
 0228 stdcall GetCursorPos(ptr) GetCursorPos32
 0229 stdcall GetDC(long) GetDC32
@@ -296,7 +296,7 @@
 0289 stdcall GetSysColorBrush(long) GetSysColorBrush32
 0290 stdcall GetSystemMenu(long long) GetSystemMenu
 0291 stdcall GetSystemMetrics(long) GetSystemMetrics
-0292 stub GetTabbedTextExtentA
+0292 stdcall GetTabbedTextExtentA(long ptr long long ptr) GetTabbedTextExtent
 0293 stub GetTabbedTextExtentW
 0294 stub GetThreadDesktop
 0295 stub GetTopWindow
@@ -452,9 +452,9 @@
 0445 stub ReuseDDElParam
 0446 stdcall ScreenToClient(long ptr) ScreenToClient32
 0447 stub ScrollChildren
-0448 stub ScrollDC
-0449 stub ScrollWindow
-0450 stub ScrollWindowEx
+0448 stdcall ScrollDC(long long long ptr ptr long ptr) ScrollDC32
+0449 stdcall ScrollWindow(long long long ptr ptr) ScrollWindow32
+0450 stdcall ScrollWindowEx(long long long ptr ptr long ptr long) ScrollWindowEx32
 0451 stdcall SendDlgItemMessageA(long long long long long) SendDlgItemMessage32A
 0452 stdcall SendDlgItemMessageW(long long long long long) SendDlgItemMessage32W
 0453 stdcall SendMessageA(long long long long) SendMessage32A
@@ -485,7 +485,7 @@
 0478 stdcall SetDlgItemTextW(long long ptr) SetDlgItemText32W
 0479 stub SetDoubleClickTime
 0480 stdcall SetFocus(long) SetFocus32
-0481 stub SetForegroundWindow
+0481 return SetForegroundWindow 4 0
 0482 stdcall SetInternalWindowPos(long long ptr ptr) SetInternalWindowPos32
 0483 stub SetKeyboardState
 0484 stdcall SetLastErrorEx(long long) SetLastErrorEx
diff --git a/if1632/wing.spec b/if1632/wing.spec
new file mode 100644
index 0000000..ec1ab43
--- /dev/null
+++ b/if1632/wing.spec
@@ -0,0 +1,20 @@
+name    wing
+type    win16
+
+1001 stub WINGCREATEDC
+1002 stub WINGRECOMMENDDIBFORMAT
+1003 stub WINGCREATEBITMAP
+1004 stub WINGGETDIBPOINTER
+1005 stub WINGGETDIBCOLORTABLE
+1006 stub WINGSETDIBCOLORTABLE
+1007 stub WINGCREATEHALFTONEPALETTE
+1008 stub WINGCREATEHALFTONEBRUSH
+1009 stub WINGSTRETCHBLT
+1010 stub WINGBITBLT
+
+# Seem that 1299 is the limit... weird...
+#1500 stub WINGINITIALIZETHUNK16
+#1501 stub WINGTHUNK16
+
+#2000 stub REGISTERWINGPAL
+#2001 stub EXCEPTIONHANDLER
diff --git a/include/callback.h b/include/callback.h
index bf94586..2f603c2 100644
--- a/include/callback.h
+++ b/include/callback.h
@@ -73,6 +73,7 @@
 /* by the build program to generate the file if1632/callto32.S */
 
 extern LONG CallTo32_0( FARPROC32 );
+extern LONG CallTo32_1( FARPROC32, DWORD );
 extern LONG CallTo32_2( FARPROC32, DWORD, DWORD );
 extern LONG CallTo32_3( FARPROC32, DWORD, DWORD, DWORD );
 extern LONG CallTo32_4( FARPROC32, DWORD, DWORD, DWORD, DWORD );
diff --git a/include/dos_fs.h b/include/dos_fs.h
index 303cbbb..4bb2b7f 100644
--- a/include/dos_fs.h
+++ b/include/dos_fs.h
@@ -26,12 +26,15 @@
 #define IS_END_OF_NAME(ch)  (!(ch) || ((ch) == '/') || ((ch) == '\\'))
 
 extern void DOSFS_ToDosDateTime( time_t unixtime, WORD *pDate, WORD *pTime );
+extern time_t DOSFS_DosDateTimeToUnixTime(WORD,WORD);
 extern const char *DOSFS_ToDosFCBFormat( const char *name );
 extern const char *DOSFS_ToDosDTAFormat( const char *name );
 extern const char *DOSFS_IsDevice( const char *name );
 extern const char * DOSFS_GetUnixFileName( const char * name, int check_last );
 extern const char * DOSFS_GetDosTrueName( const char *name, int unix_format );
 extern int DOSFS_GetDosFileName( const char *name, char *buffer, int len );
+extern time_t DOSFS_FileTimeToUnixTime(LPFILETIME ft);
+extern void DOSFS_UnixTimeToFileTime(time_t unixtime,LPFILETIME ft);
 extern int DOSFS_FindNext( const char *path, const char *short_mask,
                            const char *long_mask, int drive, BYTE attr,
                            int skip, DOS_DIRENT *entry );
diff --git a/include/libres.h b/include/libres.h
index 288f5ec..6014a3b 100644
--- a/include/libres.h
+++ b/include/libres.h
@@ -11,7 +11,8 @@
 
 extern INT32 LIBRES_AccessResource( HINSTANCE32 hModule, HRSRC32 hRsrc );
 extern HGLOBAL32 LIBRES_AllocResource( HINSTANCE32 hModule, HRSRC32 hRsrc, DWORD size );
-extern HRSRC32 LIBRES_FindResource( HINSTANCE32 hModule, LPCSTR name, LPCSTR type );
+extern HRSRC32 LIBRES_FindResource16( HINSTANCE32 hModule, LPCSTR name, LPCSTR type );
+extern HRSRC32 LIBRES_FindResource32( HINSTANCE32 hModule, LPCWSTR name, LPCWSTR type );
 extern BOOL32 LIBRES_FreeResource( HGLOBAL32 handle );
 extern HGLOBAL32 LIBRES_LoadResource( HINSTANCE32 hModule, HRSRC32 hRsrc );
 extern LPVOID LIBRES_LockResource( HGLOBAL32 handle );
diff --git a/include/metafile.h b/include/metafile.h
index a6378dd..22e0b61 100644
--- a/include/metafile.h
+++ b/include/metafile.h
@@ -32,9 +32,9 @@
                    LPCSTR str, short count, const INT16 *lpDx);
 BOOL32 MF_MetaPoly(DC *dc, short func, LPPOINT16 pt, short count);
 BOOL32 MF_BitBlt(DC *dcDest, short xDest, short yDest, short width,
-	       short height, HDC16 hdcSrc, short xSrc, short ySrc, DWORD rop);
+	       short height, DC *dcSrc, short xSrc, short ySrc, DWORD rop);
 BOOL32 MF_StretchBlt(DC *dcDest, short xDest, short yDest, short widthDest,
-		   short heightDest, HDC16 hdcSrc, short xSrc, short ySrc, 
+		   short heightDest, DC *dcSrc, short xSrc, short ySrc, 
 		   short widthSrc, short heightSrc, DWORD rop);
 
 #endif   /* METAFILE_H */
diff --git a/include/metafiledrv.h b/include/metafiledrv.h
index 519f3a5..14b2da5 100644
--- a/include/metafiledrv.h
+++ b/include/metafiledrv.h
@@ -13,10 +13,24 @@
 #define METAFILE_DISK   1
 
 /* Metafile driver physical DC */
+
 typedef struct
 {
     METAHEADER  *mh;           /* Pointer to metafile header */
     UINT32       nextHandle;   /* Next handle number */
 } METAFILEDRV_PDEVICE;
 
+
+/* Metafile driver functions */
+
+extern BOOL32 MFDRV_BitBlt( struct tagDC *dcDst, INT32 xDst, INT32 yDst,
+                            INT32 width, INT32 height, struct tagDC *dcSrc,
+                            INT32 xSrc, INT32 ySrc, DWORD rop );
+extern BOOL32 MFDRV_PatBlt( struct tagDC *dc, INT32 left, INT32 top,
+                            INT32 width, INT32 height, DWORD rop );
+extern BOOL32 MFDRV_StretchBlt( struct tagDC *dcDst, INT32 xDst, INT32 yDst,
+                                INT32 widthDst, INT32 heightDst,
+                                struct tagDC *dcSrc, INT32 xSrc, INT32 ySrc,
+                                INT32 widthSrc, INT32 heightSrc, DWORD rop );
+
 #endif  /* __WINE_METAFILEDRV_H */
diff --git a/include/region.h b/include/region.h
index eb44f4f..c5818f1 100644
--- a/include/region.h
+++ b/include/region.h
@@ -18,7 +18,7 @@
 
 
 extern BOOL32 REGION_DeleteObject( HRGN32 hrgn, RGNOBJ * obj );
-extern BOOL32 REGION_UnionRectWithRgn( HRGN32 hrgn, LPRECT16 lpRect );
+extern BOOL32 REGION_UnionRectWithRgn( HRGN32 hrgn, const RECT32 *lpRect );
 extern BOOL32 REGION_FrameRgn( HRGN32 dest, HRGN32 src, INT32 x, INT32 y );
 
 #endif  /* __WINE_REGION_H */
diff --git a/include/shell.h b/include/shell.h
index 801d857..4a7e0cd 100644
--- a/include/shell.h
+++ b/include/shell.h
@@ -32,7 +32,7 @@
 typedef struct { 	   /* structure for dropped files */ 
 	WORD		wSize;
 	POINT16		ptMousePos;   
-	BOOL		fInNonClientArea;
+	BOOL16		fInNonClientArea;
 	/* memory block with filenames follows */     
 } DROPFILESTRUCT, *LPDROPFILESTRUCT; 
 
diff --git a/include/windows.h b/include/windows.h
index 7359e0b..8e03f49 100644
--- a/include/windows.h
+++ b/include/windows.h
@@ -1521,11 +1521,15 @@
     BOOL32  bInheritHandle;
 } SECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
 
+/* 64 bit number of 100 nanoseconds intervals since January 1, 1601 */
+/* FIXME: currently dwLowDateTime is equivalent to the UNIX time(),
+ * and dwHighDateTime 0
+ */
 typedef struct
 {
   INT32  dwLowDateTime;
   INT32  dwHighDateTime;
-} FILETIME;
+} FILETIME, *LPFILETIME;
 
 /* Find* structures */
 typedef struct
@@ -2427,7 +2431,7 @@
 /* Window scrolling */
 #define SW_SCROLLCHILDREN      0x0001
 #define SW_INVALIDATE          0x0002
-#define SW_ERASE               0x0003
+#define SW_ERASE               0x0004
 
 /* CreateWindow() coordinates */
 #define CW_USEDEFAULT16 ((INT16)0x8000)
@@ -2766,31 +2770,108 @@
 #define CBS_DISABLENOSCROLL   0x0800L
 
 /* Combo box messages */
-#define CB_GETEDITSEL            (WM_USER+0)
-#define CB_LIMITTEXT             (WM_USER+1)
-#define CB_SETEDITSEL            (WM_USER+2)
-#define CB_ADDSTRING             (WM_USER+3)
-#define CB_DELETESTRING          (WM_USER+4)
-#define CB_DIR                   (WM_USER+5)
-#define CB_GETCOUNT              (WM_USER+6)
-#define CB_GETCURSEL             (WM_USER+7)
-#define CB_GETLBTEXT             (WM_USER+8)
-#define CB_GETLBTEXTLEN          (WM_USER+9)
-#define CB_INSERTSTRING          (WM_USER+10)
-#define CB_RESETCONTENT          (WM_USER+11)
-#define CB_FINDSTRING            (WM_USER+12)
-#define CB_SELECTSTRING          (WM_USER+13)
-#define CB_SETCURSEL             (WM_USER+14)
-#define CB_SHOWDROPDOWN          (WM_USER+15)
-#define CB_GETITEMDATA           (WM_USER+16)
-#define CB_SETITEMDATA           (WM_USER+17)
-#define CB_GETDROPPEDCONTROLRECT (WM_USER+18)
-#define CB_SETITEMHEIGHT         (WM_USER+19)
-#define CB_GETITEMHEIGHT         (WM_USER+20)
-#define CB_SETEXTENDEDUI         (WM_USER+21)
-#define CB_GETEXTENDEDUI         (WM_USER+22)
-#define CB_GETDROPPEDSTATE       (WM_USER+23)
-#define CB_FINDSTRINGEXACT       (WM_USER+24)
+#define CB_GETEDITSEL16            (WM_USER+0)
+#define CB_GETEDITSEL32            0x0140
+#define CB_GETEDITSEL              WINELIB_NAME(CB_GETEDITSEL)
+#define CB_LIMITTEXT16             (WM_USER+1)
+#define CB_LIMITTEXT32             0x0141
+#define CB_LIMITTEXT               WINELIB_NAME(CB_LIMITTEXT)
+#define CB_SETEDITSEL16            (WM_USER+2)
+#define CB_SETEDITSEL32            0x0142
+#define CB_SETEDITSEL              WINELIB_NAME(CB_SETEDITSEL)
+#define CB_ADDSTRING16             (WM_USER+3)
+#define CB_ADDSTRING32             0x0143
+#define CB_ADDSTRING               WINELIB_NAME(CB_ADDSTRING)
+#define CB_DELETESTRING16          (WM_USER+4)
+#define CB_DELETESTRING32          0x0144
+#define CB_DELETESTRING            WINELIB_NAME(CB_DELETESTRING)
+#define CB_DIR16                   (WM_USER+5)
+#define CB_DIR32                   0x0145
+#define CB_DIR                     WINELIB_NAME(CB_DIR)
+#define CB_GETCOUNT16              (WM_USER+6)
+#define CB_GETCOUNT32              0x0146
+#define CB_GETCOUNT                WINELIB_NAME(CB_GETCOUNT)
+#define CB_GETCURSEL16             (WM_USER+7)
+#define CB_GETCURSEL32             0x0147
+#define CB_GETCURSEL               WINELIB_NAME(CB_GETCURSEL)
+#define CB_GETLBTEXT16             (WM_USER+8)
+#define CB_GETLBTEXT32             0x0148
+#define CB_GETLBTEXT               WINELIB_NAME(CB_GETLBTEXT)
+#define CB_GETLBTEXTLEN16          (WM_USER+9)
+#define CB_GETLBTEXTLEN32          0x0149
+#define CB_GETLBTEXTLEN            WINELIB_NAME(CB_GETLBTEXTLEN)
+#define CB_INSERTSTRING16          (WM_USER+10)
+#define CB_INSERTSTRING32          0x014a
+#define CB_INSERTSTRING            WINELIB_NAME(CB_INSERTSTRING)
+#define CB_RESETCONTENT16          (WM_USER+11)
+#define CB_RESETCONTENT32          0x014b
+#define CB_RESETCONTENT            WINELIB_NAME(CB_RESETCONTENT)
+#define CB_FINDSTRING16            (WM_USER+12)
+#define CB_FINDSTRING32            0x014c
+#define CB_FINDSTRING              WINELIB_NAME(CB_FINDSTRING)
+#define CB_SELECTSTRING16          (WM_USER+13)
+#define CB_SELECTSTRING32          0x014d
+#define CB_SELECTSTRING            WINELIB_NAME(CB_SELECTSTRING)
+#define CB_SETCURSEL16             (WM_USER+14)
+#define CB_SETCURSEL32             0x014e
+#define CB_SETCURSEL               WINELIB_NAME(CB_SETCURSEL)
+#define CB_SHOWDROPDOWN16          (WM_USER+15)
+#define CB_SHOWDROPDOWN32          0x014f
+#define CB_SHOWDROPDOWN            WINELIB_NAME(CB_SHOWDROPDOWN)
+#define CB_GETITEMDATA16           (WM_USER+16)
+#define CB_GETITEMDATA32           0x0150
+#define CB_GETITEMDATA             WINELIB_NAME(CB_GETITEMDATA)
+#define CB_SETITEMDATA16           (WM_USER+17)
+#define CB_SETITEMDATA32           0x0151
+#define CB_SETITEMDATA             WINELIB_NAME(CB_SETITEMDATA)
+#define CB_GETDROPPEDCONTROLRECT16 (WM_USER+18)
+#define CB_GETDROPPEDCONTROLRECT32 0x0152
+#define CB_GETDROPPEDCONTROLRECT   WINELIB_NAME(CB_GETDROPPEDCONTROLRECT)
+#define CB_SETITEMHEIGHT16         (WM_USER+19)
+#define CB_SETITEMHEIGHT32         0x0153
+#define CB_SETITEMHEIGHT           WINELIB_NAME(CB_SETITEMHEIGHT)
+#define CB_GETITEMHEIGHT16         (WM_USER+20)
+#define CB_GETITEMHEIGHT32         0x0154
+#define CB_GETITEMHEIGHT           WINELIB_NAME(CB_GETITEMHEIGHT)
+#define CB_SETEXTENDEDUI16         (WM_USER+21)
+#define CB_SETEXTENDEDUI32         0x0155
+#define CB_SETEXTENDEDUI           WINELIB_NAME(CB_SETEXTENDEDUI)
+#define CB_GETEXTENDEDUI16         (WM_USER+22)
+#define CB_GETEXTENDEDUI32         0x0156
+#define CB_GETEXTENDEDUI           WINELIB_NAME(CB_GETEXTENDEDUI)
+#define CB_GETDROPPEDSTATE16       (WM_USER+23)
+#define CB_GETDROPPEDSTATE32       0x0157
+#define CB_GETDROPPEDSTATE         WINELIB_NAME(CB_GETDROPPEDSTATE)
+#define CB_FINDSTRINGEXACT16       (WM_USER+24)
+#define CB_FINDSTRINGEXACT32       0x0158
+#define CB_FINDSTRINGEXACT         WINELIB_NAME(CB_FINDSTRINGEXACT)
+#define CB_SETLOCALE16             WM_NULL  /* Not in Win16 */
+#define CB_SETLOCALE32             0x0159
+#define CB_SETLOCALE               WINELIB_NAME(CB_SETLOCALE)
+#define CB_GETLOCALE16             WM_NULL  /* Not in Win16 */
+#define CB_GETLOCALE32             0x015a
+#define CB_GETLOCALE               WINELIB_NAME(CB_GETLOCALE)
+#define CB_GETTOPINDEX16           WM_NULL  /* Not in Win16 */
+#define CB_GETTOPINDEX32           0x015b
+#define CB_GETTOPINDEX             WINELIB_NAME(CB_GETTOPINDEX)
+#define CB_SETTOPINDEX16           WM_NULL  /* Not in Win16 */
+#define CB_SETTOPINDEX32           0x015c
+#define CB_SETTOPINDEX             WINELIB_NAME(CB_SETTOPINDEX)
+#define CB_GETHORIZONTALEXTENT16   WM_NULL  /* Not in Win16 */
+#define CB_GETHORIZONTALEXTENT32   0x015d
+#define CB_GETHORIZONTALEXTENT     WINELIB_NAME(CB_GETHORIZONTALEXTENT)
+#define CB_SETHORIZONTALEXTENT16   WM_NULL  /* Not in Win16 */
+#define CB_SETHORIZONTALEXTENT32   0x015e
+#define CB_SETHORIZONTALEXTENT     WINELIB_NAME(CB_SETHORIZONTALEXTENT)
+#define CB_GETDROPPEDWIDTH16       WM_NULL  /* Not in Win16 */
+#define CB_GETDROPPEDWIDTH32       0x015f
+#define CB_GETDROPPEDWIDTH         WINELIB_NAME(CB_GETDROPPEDWIDTH)
+#define CB_SETDROPPEDWIDTH16       WM_NULL  /* Not in Win16 */
+#define CB_SETDROPPEDWIDTH32       0x0160
+#define CB_SETDROPPEDWIDTH         WINELIB_NAME(CB_SETDROPPEDWIDTH)
+#define CB_INITSTORAGE16           WM_NULL  /* Not in Win16 */
+#define CB_INITSTORAGE32           0x0161
+#define CB_INITSTORAGE             WINELIB_NAME(CB_INITSTORAGE)
 
 /* Combo box notification codes */
 #define CBN_ERRSPACE        (-1)
@@ -3624,6 +3705,19 @@
 typedef BOOL32 (*CODEPAGE_ENUMPROC32W)(LPWSTR);
 DECL_WINELIB_TYPE_AW(CODEPAGE_ENUMPROC);
 
+typedef struct tagSYSTEM_INFO
+{
+    DWORD   dwOemId;
+    DWORD   dwPageSize;
+    LPVOID  lpMinimumApplicationAddress;
+    LPVOID  lpMaximumApplicationAddress;
+    DWORD   dwActiveProcessorMask;
+    DWORD   dwNumberOfProcessors;
+    DWORD   dwProcessorType;
+    DWORD   dwAllocationGranularity;
+    DWORD   dwReserved;
+} SYSTEM_INFO, *LPSYSTEM_INFO;
+
 #pragma pack(4)
 
 /* Declarations for functions that exist only in Win16 */
@@ -3638,10 +3732,13 @@
 BOOL16     DCHook(HDC16,WORD,DWORD,LPARAM);
 VOID       DirectedYield(HTASK16);
 HGLOBAL16  DirectResAlloc(HINSTANCE16,WORD,UINT16);
+BOOL16     DlgDirSelect(HWND16,LPSTR,INT16);
+BOOL16     DlgDirSelectComboBox(HWND16,LPSTR,INT16);
 BOOL16     EnableHardwareInput(BOOL16);
 INT16      ExcludeVisRect(HDC16,INT16,INT16,INT16,INT16);
 HANDLE16   FarGetOwner(HGLOBAL16);
 VOID       FarSetOwner(HGLOBAL16,HANDLE16);
+BOOL16     FastWindowFrame(HDC16,const RECT16*,INT16,INT16,DWORD);
 VOID       FillWindow(HWND16,HWND16,HDC16,HBRUSH16);
 INT16      FlushComm(INT16,INT16);
 WORD       FreeSelector(WORD);
@@ -3731,11 +3828,18 @@
 HANDLE32   CreateFileMapping32A(HANDLE32,LPSECURITY_ATTRIBUTES,DWORD,DWORD,DWORD,LPCSTR);
 HANDLE32   CreateFileMapping32W(HANDLE32,LPSECURITY_ATTRIBUTES,DWORD,DWORD,DWORD,LPCWSTR);
 #define    CreateFileMapping WINELIB_NAME_AW(CreateFileMapping)
+BOOL32     DosDateTimeToFileTime(WORD,WORD,LPFILETIME);
 INT32      EnumPropsEx32A(HWND32,PROPENUMPROCEX32A,LPARAM);
 INT32      EnumPropsEx32W(HWND32,PROPENUMPROCEX32W,LPARAM);
 #define    EnumPropsEx WINELIB_NAME_AW(EnumPropsEx)
+BOOL32     EnumSystemCodePages32A(CODEPAGE_ENUMPROC32A,DWORD);
+BOOL32     EnumSystemCodePages32W(CODEPAGE_ENUMPROC32W,DWORD);
+#define    EnumSystemCodePages WINELIB_NAME_AW(EnumSystemCodePages)
 BOOL32     EnumThreadWindows(DWORD,WNDENUMPROC32,LPARAM);
 void       ExitProcess(DWORD);
+BOOL32     FileTimeToDosDateTime(LPFILETIME,LPWORD,LPWORD);
+BOOL32     FileTimeToLocalFileTime(LPFILETIME,LPFILETIME);
+BOOL32     FileTimeToSystemTime(LPFILETIME,LPSYSTEMTIME);
 HRSRC32    FindResourceEx32A(HINSTANCE32,LPCSTR,LPCSTR,WORD);
 HRSRC32    FindResourceEx32W(HINSTANCE32,LPCWSTR,LPCWSTR,WORD);
 #define    FindResourceEx WINELIB_NAME_AW(FindResourceEx)
@@ -3745,6 +3849,8 @@
 #define    GetCommandLine WINELIB_NAME_AW(GetCommandLine)
 BOOL32     GetCommTimeouts(INT32,LPCOMMTIMEOUTS);
 DWORD      GetFileInformationByHandle(HFILE,BY_HANDLE_FILE_INFORMATION*);
+DWORD      GetFileSize(HFILE,LPDWORD);
+DWORD      GetFileType(HFILE);
 VOID       GetLocalTime(LPSYSTEMTIME);
 DWORD      GetLogicalDrives(void);
 HANDLE32   GetProcessHeap(void);
@@ -3752,6 +3858,7 @@
 DWORD      GetShortPathName32W(LPCWSTR,LPWSTR,DWORD);
 #define    GetShortPathName WINELIB_NAME_AW(GetShortPathName)
 HFILE      GetStdHandle(DWORD);
+VOID       GetSystemInfo(LPSYSTEM_INFO);
 BOOL32     GetSystemPowerStatus(LPSYSTEM_POWER_STATUS);
 VOID       GetSystemTime(LPSYSTEMTIME);
 VOID       GlobalMemoryStatus(LPMEMORYSTATUS);
@@ -3766,6 +3873,7 @@
 BOOL32     HeapUnlock(HANDLE32);
 BOOL32     HeapValidate(HANDLE32,DWORD,LPVOID);
 BOOL32     IsWindowUnicode(HWND32);
+BOOL32     LocalFileTimeToFileTime(LPFILETIME,LPFILETIME);
 LPVOID     MapViewOfFileEx(HANDLE32,DWORD,DWORD,DWORD,DWORD,DWORD);
 BOOL32     MoveFile32A(LPCSTR,LPCSTR);
 BOOL32     MoveFile32W(LPCWSTR,LPCWSTR);
@@ -3777,16 +3885,16 @@
 DWORD      RegCreateKeyEx32W(HKEY,LPCWSTR,DWORD,LPWSTR,DWORD,REGSAM,
                              LPSECURITY_ATTRIBUTES,LPHKEY,LPDWORD);
 #define    RegCreateKeyEx WINELIB_NAME_AW(RegCreateKeyEx)
-DWORD      RegEnumKeyEx32A(HKEY,DWORD,LPSTR,LPDWORD,LPDWORD,LPSTR,LPDWORD,FILETIME*);
-DWORD      RegEnumKeyEx32W(HKEY,DWORD,LPWSTR,LPDWORD,LPDWORD,LPWSTR,LPDWORD,FILETIME*);
+DWORD      RegEnumKeyEx32A(HKEY,DWORD,LPSTR,LPDWORD,LPDWORD,LPSTR,LPDWORD,LPFILETIME);
+DWORD      RegEnumKeyEx32W(HKEY,DWORD,LPWSTR,LPDWORD,LPDWORD,LPWSTR,LPDWORD,LPFILETIME);
 #define    RegEnumKeyEx WINELIB_NAME_AW(RegEnumKeyEx)
 DWORD      RegOpenKeyEx32W(HKEY,LPCWSTR,DWORD,REGSAM,LPHKEY);
 DWORD      RegOpenKeyEx32A(HKEY,LPCSTR,DWORD,REGSAM,LPHKEY);
 #define    RegOpenKeyEx WINELIB_NAME_AW(RegOpenKeyEx)
 DWORD      RegQueryInfoKey32W(HKEY,LPWSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD,
-                            LPDWORD,LPDWORD,LPDWORD,LPDWORD,LPDWORD,FILETIME*);
+                            LPDWORD,LPDWORD,LPDWORD,LPDWORD,LPDWORD,LPFILETIME);
 DWORD      RegQueryInfoKey32A(HKEY,LPSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD,
-                            LPDWORD,LPDWORD,LPDWORD,LPDWORD,LPDWORD,FILETIME*);
+                            LPDWORD,LPDWORD,LPDWORD,LPDWORD,LPDWORD,LPFILETIME);
 #define    RegQueryInfoKey WINELIB_NAME_AW(RegQueryInfoKey)
 VOID       RtlFillMemory(LPVOID,UINT32,UINT32);
 VOID       RtlMoveMemory(LPVOID,LPCVOID,UINT32);
@@ -3799,10 +3907,12 @@
 BOOL32     SetCommTimeouts(INT32,LPCOMMTIMEOUTS);
 BOOL32     SetEndOfFile(HFILE);
 DWORD      SetFilePointer(HFILE,LONG,LPLONG,DWORD);
+BOOL32     SetFileTime(HFILE,LPFILETIME,LPFILETIME,LPFILETIME);
 BOOL32     SetTimeZoneInformation(const LPTIME_ZONE_INFORMATION);
 BOOL32     SetSystemPowerState(BOOL32,BOOL32);
 BOOL32     SetSystemTime(const SYSTEMTIME*);
 VOID       Sleep(DWORD);
+BOOL32     SystemTimeToFileTime(LPSYSTEMTIME,LPFILETIME);
 LPVOID     VirtualAlloc(LPVOID,DWORD,DWORD,DWORD);
 BOOL32     VirtualFree(LPVOID,DWORD,DWORD);
 BOOL32     WriteFile(HFILE,LPVOID,DWORD,LPDWORD,LPOVERLAPPED);
@@ -3887,6 +3997,9 @@
 HDC16      BeginPaint16(HWND16,LPPAINTSTRUCT16);
 HDC32      BeginPaint32(HWND32,LPPAINTSTRUCT32);
 #define    BeginPaint WINELIB_NAME(BeginPaint)
+BOOL16     BitBlt16(HDC16,INT16,INT16,INT16,INT16,HDC16,INT16,INT16,DWORD);
+BOOL32     BitBlt32(HDC32,INT32,INT32,INT32,INT32,HDC32,INT32,INT32,DWORD);
+#define    BitBlt WINELIB_NAME(BitBlt)
 BOOL16     BuildCommDCB16(LPCSTR,LPDCB16);
 BOOL32     BuildCommDCB32A(LPCSTR,LPDCB32);
 BOOL32     BuildCommDCB32W(LPCWSTR,LPDCB32);
@@ -4111,6 +4224,14 @@
 INT32      DlgDirListComboBox32A(HWND32,LPCSTR,INT32,INT32,UINT32);
 INT32      DlgDirListComboBox32W(HWND32,LPCWSTR,INT32,INT32,UINT32);
 #define    DlgDirListComboBox WINELIB_NAME_AW(DlgDirListComboBox)
+BOOL16     DlgDirSelectComboBoxEx16(HWND16,LPSTR,INT16,INT16);
+BOOL32     DlgDirSelectComboBoxEx32A(HWND32,LPSTR,INT32,INT32);
+BOOL32     DlgDirSelectComboBoxEx32W(HWND32,LPWSTR,INT32,INT32);
+#define    DlgDirSelectComboBoxEx WINELIB_NAME_AW(DlgDirSelectComboBoxEx)
+BOOL16     DlgDirSelectEx16(HWND16,LPSTR,INT16,INT16);
+BOOL32     DlgDirSelectEx32A(HWND32,LPSTR,INT32,INT32);
+BOOL32     DlgDirSelectEx32W(HWND32,LPWSTR,INT32,INT32);
+#define    DlgDirSelectEx WINELIB_NAME_AW(DlgDirSelectEx)
 BOOL16     DPtoLP16(HDC16,LPPOINT16,INT16);
 BOOL32     DPtoLP32(HDC32,LPPOINT32,INT32);
 #define    DPtoLP WINELIB_NAME(DPtoLP)
@@ -4139,6 +4260,10 @@
 BOOL16     EnumChildWindows16(HWND16,WNDENUMPROC16,LPARAM);
 BOOL32     EnumChildWindows32(HWND32,WNDENUMPROC32,LPARAM);
 #define    EnumChildWindows WINELIB_NAME(EnumChildWindows)
+INT16      EnumFontFamilies16(HDC16,LPCSTR,FONTENUMPROC16,LPARAM);
+INT32      EnumFontFamilies32A(HDC32,LPCSTR,FONTENUMPROC32A,LPARAM);
+INT32      EnumFontFamilies32W(HDC32,LPCWSTR,FONTENUMPROC32W,LPARAM);
+#define    EnumFontFamilies WINELIB_NAME_AW(EnumFontFamilies)
 INT16      EnumObjects16(HDC16,INT16,GOBJENUMPROC16,LPARAM);
 INT32      EnumObjects32(HDC32,INT32,GOBJENUMPROC32,LPARAM);
 #define    EnumObjects WINELIB_NAME(EnumObjects)
@@ -4657,6 +4782,9 @@
 BOOL16     PaintRgn16(HDC16,HRGN16);
 BOOL32     PaintRgn32(HDC32,HRGN32);
 #define    PaintRgn WINELIB_NAME(PaintRgn)
+BOOL16     PatBlt16(HDC16,INT16,INT16,INT16,INT16,DWORD);
+BOOL32     PatBlt32(HDC32,INT32,INT32,INT32,INT32,DWORD);
+#define    PatBlt WINELIB_NAME(PatBlt)
 BOOL16     PeekMessage16(LPMSG16,HWND16,UINT16,UINT16,UINT16);
 BOOL32     PeekMessage32A(LPMSG32,HWND32,UINT32,UINT32,UINT32);
 BOOL32     PeekMessage32W(LPMSG32,HWND32,UINT32,UINT32,UINT32);
@@ -4775,6 +4903,19 @@
 void       ScreenToClient16(HWND16,LPPOINT16);
 void       ScreenToClient32(HWND32,LPPOINT32);
 #define    ScreenToClient WINELIB_NAME(ScreenToClient)
+BOOL16     ScrollDC16(HDC16,INT16,INT16,const RECT16*,const RECT16*,
+                      HRGN16,LPRECT16);
+BOOL32     ScrollDC32(HDC32,INT32,INT32,const RECT32*,const RECT32*,
+                      HRGN32,LPRECT32);
+#define    ScrollDC WINELIB_NAME(ScrollDC)
+void       ScrollWindow16(HWND16,INT16,INT16,const RECT16*,const RECT16*);
+BOOL32     ScrollWindow32(HWND32,INT32,INT32,const RECT32*,const RECT32*);
+#define    ScrollWindow WINELIB_NAME(ScrollWindow)
+INT16      ScrollWindowEx16(HWND16,INT16,INT16,const RECT16*,const RECT16*,
+                            HRGN16,LPRECT16,UINT16);
+INT32      ScrollWindowEx32(HWND32,INT32,INT32,const RECT32*,const RECT32*,
+                            HRGN32,LPRECT32,UINT32);
+#define    ScrollWindowEx WINELIB_NAME(ScrollWindowEx)
 INT16      SelectClipRgn16(HDC16,HRGN16);
 INT32      SelectClipRgn32(HDC32,HRGN32);
 #define    SelectClipRgn WINELIB_NAME(SelectClipRgn)
@@ -4896,6 +5037,11 @@
 void       ShowScrollBar16(HWND16,INT16,BOOL16);
 BOOL32     ShowScrollBar32(HWND32,INT32,BOOL32);
 #define    ShowScrollBar WINELIB_NAME(ShowScrollBar)
+BOOL16     StretchBlt16(HDC16,INT16,INT16,INT16,INT16,HDC16,INT16,INT16,
+                        INT16,INT16,DWORD);
+BOOL32     StretchBlt32(HDC32,INT32,INT32,INT32,INT32,HDC32,INT32,INT32,
+                        INT32,INT32,DWORD);
+#define    StretchBlt WINELIB_NAME(StretchBlt)
 BOOL16     SubtractRect16(LPRECT16,const RECT16*,const RECT16*);
 BOOL32     SubtractRect32(LPRECT32,const RECT32*,const RECT32*);
 #define    SubtractRect WINELIB_NAME(SubtractRect)
@@ -5059,7 +5205,6 @@
 BOOL       AnyPopup(void);
 UINT       ArrangeIconicWindows(HWND);
 HDWP16     BeginDeferWindowPos(INT);
-BOOL       BitBlt(HDC16,INT,INT,INT,INT,HDC16,INT,INT,DWORD);
 BOOL       BringWindowToTop(HWND);
 void       CalcChildScroll(HWND,WORD);
 BOOL       CallMsgFilter(SEGPTR,INT);
@@ -5094,8 +5239,6 @@
 BOOL       DestroyWindow(HWND);
 LONG       DispatchMessage(const MSG16*);
 INT        DlgDirList(HWND,SEGPTR,INT,INT,UINT);
-BOOL       DlgDirSelect(HWND,LPSTR,INT);
-BOOL       DlgDirSelectComboBox(HWND,LPSTR,INT);
 BOOL16     DragDetect(HWND16,POINT16);
 DWORD      DragObject(HWND, HWND, WORD, HANDLE16, WORD, HCURSOR16);
 BOOL       DrawIcon(HDC16,INT,INT,HICON16);
@@ -5106,7 +5249,6 @@
 BOOL       EnableWindow(HWND,BOOL);
 BOOL       EndDeferWindowPos(HDWP16);
 UINT16     EnumClipboardFormats(UINT16);
-INT        EnumFontFamilies(HDC16,LPCSTR,FONTENUMPROC16,LPARAM);
 INT        EnumFonts(HDC16,LPCSTR,FONTENUMPROC16,LPARAM);
 BOOL       EnumMetaFile(HDC16,HMETAFILE16,MFENUMPROC16,LPARAM);
 INT        Escape(HDC16,INT,INT,SEGPTR,SEGPTR);
@@ -5249,7 +5391,6 @@
 BOOL       OpenIcon(HWND);
 int        OpenSound(void);
 void       OutputDebugString(LPCSTR);
-BOOL       PatBlt(HDC16,short,short,short,short,DWORD);
 BOOL       PlayMetaFile(HDC16,HMETAFILE16);
 void       PlayMetaFileRecord(HDC16,LPHANDLETABLE16,LPMETARECORD,WORD);
 BOOL       PostMessage(HWND,WORD,WORD,LONG);
@@ -5272,9 +5413,6 @@
 BOOL       RestoreDC(HDC16,short);
 int        SaveDC(HDC16);
 void       ScrollChildren(HWND,UINT,WPARAM16,LPARAM);
-BOOL       ScrollDC(HDC16,short,short,LPRECT16,LPRECT16,HRGN32,LPRECT16);
-void       ScrollWindow(HWND,short,short,LPRECT16,LPRECT16);
-int        ScrollWindowEx(HWND,short,short,LPRECT16,LPRECT16,HRGN32,LPRECT16,WORD);
 HPALETTE16 SelectPalette(HDC16,HPALETTE16,BOOL);
 HWND       SetActiveWindow(HWND);
 WORD       SetBkMode(HDC16,WORD);
@@ -5326,7 +5464,6 @@
 DWORD      SizeofResource(HMODULE16,HRSRC16);
 int        StartSound(void);
 int        StopSound(void);
-BOOL       StretchBlt(HDC16,short,short,short,short,HDC16,short,short,short,short,DWORD);
 int        StretchDIBits(HDC16,WORD,WORD,WORD,WORD,WORD,WORD,WORD,WORD,LPSTR,LPBITMAPINFO,WORD,DWORD);
 BOOL       SwapMouseButton(BOOL);
 void       SwapRecording(WORD);
diff --git a/include/winpos.h b/include/winpos.h
index 2b30dd3..d8df072 100644
--- a/include/winpos.h
+++ b/include/winpos.h
@@ -35,6 +35,6 @@
 				  RECT16 *newClientRect );
 extern LONG WINPOS_HandleWindowPosChanging16(WND *wndPtr, WINDOWPOS16 *winpos);
 extern LONG WINPOS_HandleWindowPosChanging32(WND *wndPtr, WINDOWPOS32 *winpos);
-extern INT16 WINPOS_WindowFromPoint( POINT16 pt, WND **ppWnd );
+extern INT16 WINPOS_WindowFromPoint( WND* scopeWnd, POINT16 pt, WND **ppWnd );
 
 #endif  /* __WINE_WINPOS_H */
diff --git a/include/x11drv.h b/include/x11drv.h
index eea87db..0c811a4 100644
--- a/include/x11drv.h
+++ b/include/x11drv.h
@@ -50,8 +50,17 @@
 
 struct tagDC;
 
+extern BOOL32 X11DRV_BitBlt( struct tagDC *dcDst, INT32 xDst, INT32 yDst,
+                             INT32 width, INT32 height, struct tagDC *dcSrc,
+                             INT32 xSrc, INT32 ySrc, DWORD rop );
 extern BOOL32 X11DRV_GetTextExtentPoint( struct tagDC *dc, LPCSTR str,
                                          INT32 count, LPSIZE32 size );
+extern BOOL32 X11DRV_PatBlt( struct tagDC *dc, INT32 left, INT32 top,
+                             INT32 width, INT32 height, DWORD rop );
 extern VOID X11DRV_SetDeviceClipping(struct tagDC *dc);
+extern BOOL32 X11DRV_StretchBlt( struct tagDC *dcDst, INT32 xDst, INT32 yDst,
+                                 INT32 widthDst, INT32 heightDst,
+                                 struct tagDC *dcSrc, INT32 xSrc, INT32 ySrc,
+                                 INT32 widthSrc, INT32 heightSrc, DWORD rop );
 
 #endif  /* __WINE_X11DRV_H */
diff --git a/library/libres.c b/library/libres.c
index c3964ec..521f7c2 100644
--- a/library/libres.c
+++ b/library/libres.c
@@ -9,6 +9,7 @@
 #include "libres.h"
 #include "windows.h"
 #include "xmalloc.h"
+#include "string32.h"
 
 typedef struct RLE
 {
@@ -30,9 +31,9 @@
 }
 
 /**********************************************************************
- *	    LIBRES_FindResource    
+ *	    LIBRES_FindResource16    
  */
-HRSRC32 LIBRES_FindResource( HINSTANCE32 hModule, LPCSTR name, LPCSTR type )
+HRSRC32 LIBRES_FindResource16( HINSTANCE32 hModule, LPCSTR name, LPCSTR type )
 {
   int nameid=0,typeid;
   ResListE* ResBlock;
@@ -57,7 +58,7 @@
       typeid=atoi(type+1);
     else
     {
-      WINELIB_UNIMP("LIBRES_FindResource(*,*,type=string)");
+      WINELIB_UNIMP("LIBRES_FindResource16(*,*,type=string)");
       return 0;
     }
   }
@@ -77,6 +78,61 @@
   return 0;
 }
 
+/**********************************************************************
+ *	    LIBRES_FindResource32    
+ */
+HRSRC32 LIBRES_FindResource32( HINSTANCE32 hModule, LPCWSTR name, LPCWSTR type )
+{
+  int nameid=0,typeid;
+  ResListE* ResBlock;
+  const struct resource* const * Res;
+  LPSTR nameA, typeA;
+
+  if(HIWORD(name))
+  {
+    if(*name=='#')
+    {
+      nameA = STRING32_DupUniToAnsi(name);
+      nameid=atoi(nameA+1);
+      free(nameA);
+      name=NULL;
+    }
+  }
+  else
+  {
+    nameid=LOWORD(name);
+    name=NULL;
+  }
+  if(HIWORD(type))
+  {
+    if(*type=='#')
+    {
+      typeA = STRING32_DupUniToAnsi(type);
+      typeid=atoi(typeA+1);
+      free(typeA);
+    }
+    else
+    {
+      WINELIB_UNIMP("LIBRES_FindResource32(*,*,type=string)");
+      return 0;
+    }
+  }
+  else
+    typeid=LOWORD(type);
+  
+  for(ResBlock=ResourceList; ResBlock; ResBlock=ResBlock->next)
+    for(Res=ResBlock->Resources; *Res; Res++)
+      if(name)
+      {
+	if((*Res)->type==typeid && !lstrcmpi32W((*Res)->name,name))
+	  return (HRSRC32)*Res;
+      }
+      else
+	if((*Res)->type==typeid && (*Res)->id==nameid)
+	  return (HRSRC32)*Res;
+  return 0;
+}
+
 
 /**********************************************************************
  *	    LIBRES_LoadResource    
diff --git a/loader/builtin.c b/loader/builtin.c
index 0b67254..0a12bc6 100644
--- a/loader/builtin.c
+++ b/loader/builtin.c
@@ -90,6 +90,7 @@
 extern const DLL_DESCRIPTOR LZEXPAND_Descriptor;
 extern const DLL_DESCRIPTOR VER_Descriptor;
 extern const DLL_DESCRIPTOR W32SYS_Descriptor;
+extern const DLL_DESCRIPTOR WING_Descriptor;
 
 /* 32-bit DLLs */
 
@@ -143,6 +144,7 @@
     { &LZEXPAND_Descriptor, 0 },
     { &VER_Descriptor,      0 },
     { &W32SYS_Descriptor,   0 },
+    { &WING_Descriptor,     0 },
     /* Win32 DLLs */
     { &ADVAPI32_Descriptor, 0 },
     { &COMCTL32_Descriptor, DLL_FLAG_NOT_USED },
diff --git a/loader/resource.c b/loader/resource.c
index 9bf8dba..cf7cc0b 100644
--- a/loader/resource.c
+++ b/loader/resource.c
@@ -63,7 +63,7 @@
     }
     return NE_FindResource( hModule, type, name );
 #else
-    return LIBRES_FindResource( hModule, name, type );
+    return LIBRES_FindResource16( hModule, name, type );
 #endif
 }
 
@@ -116,7 +116,7 @@
     if (!(pModule->flags & NE_FFLAGS_WIN32)) return 0;
     return PE_FindResourceEx32W(hModule,name,type,lang);
 #else
-    return LIBRES_FindResource( hModule, name, type );
+    return LIBRES_FindResource32( hModule, name, type );
 #endif
 }
 
@@ -661,6 +661,7 @@
     LPWSTR buffer2 = buffer?(LPWSTR)xmalloc(buflen*2):NULL;
     INT32 retval = LoadString32W(instance,resource_id,buffer2,buflen);
 
+    if (!retval) return 0;
     if (buffer) {
 	STRING32_UniToAnsi(buffer,buffer2);
 	free(buffer2);
diff --git a/memory/global.c b/memory/global.c
index 4718a63..876c6c9 100644
--- a/memory/global.c
+++ b/memory/global.c
@@ -750,52 +750,23 @@
 /***********************************************************************
  *           MemManInfo   (TOOLHELP.72)
  */
-BOOL16 MemManInfo( MEMMANINFO *pInfo )
+BOOL16 MemManInfo( MEMMANINFO *info )
 {
-#ifdef linux
-    /* FIXME: does not take into account the dwSize member
-     * could be corrupting memory therefore
-     */
-    /* shamefully stolen from free */
-    DWORD availmem = 0;
-    DWORD totalmem = 0;
-    FILE *meminfo;
-    char buf[80];
-    int col[5];
-    int n;
+    MEMORYSTATUS status;
 
-    if ((meminfo = fopen("/proc/meminfo", "r")) < 0) {
-        perror("wine: open");
-        return FALSE;
-    }
-
-    fgets(buf, 80, meminfo); /* read first line */
-    while ( fgets(buf, 80, meminfo) ) {
-        n = sscanf( buf, "%*s %d %d %d %d %d", &col[0], &col[1], &col[2], &col[3], &col[4]);
-        if ( n < 1 ) continue; /* escape the loop at the top */
-        totalmem += col[0];
-        availmem += col[2] + col[4];
-    }
-
-    fprintf(stderr,"MemManInfo called with dwSize = %ld\n",pInfo->dwSize);
-    if (pInfo->dwSize) {
-        pInfo->wPageSize = getpagesize();
-        pInfo->dwLargestFreeBlock = availmem;
-        pInfo->dwTotalLinearSpace = totalmem / pInfo->wPageSize;
-        pInfo->dwMaxPagesAvailable = pInfo->dwLargestFreeBlock / pInfo->wPageSize;
-        pInfo->dwMaxPagesLockable = pInfo->dwMaxPagesLockable;
-        /* FIXME: the next three are not quite correct */
-        pInfo->dwTotalUnlockedPages = pInfo->dwMaxPagesAvailable;
-        pInfo->dwFreePages = pInfo->dwMaxPagesAvailable;
-        pInfo->dwTotalPages = pInfo->dwMaxPagesAvailable;
-        /* FIXME: the three above are not quite correct */
-        pInfo->dwFreeLinearSpace = pInfo->dwMaxPagesAvailable;
-        pInfo->dwSwapFilePages = 0L;
-    }
+    if (info->dwSize < sizeof(MEMMANINFO)) return FALSE;
+    GlobalMemoryStatus( &status );
+    info->wPageSize            = getpagesize();
+    info->dwLargestFreeBlock   = status.dwAvailVirtual;
+    info->dwMaxPagesAvailable  = info->dwLargestFreeBlock / info->wPageSize;
+    info->dwMaxPagesLockable   = info->dwMaxPagesAvailable;
+    info->dwTotalLinearSpace   = status.dwTotalVirtual / info->wPageSize;
+    info->dwTotalUnlockedPages = info->dwTotalLinearSpace;
+    info->dwFreePages          = info->dwMaxPagesAvailable;
+    info->dwTotalPages         = info->dwTotalLinearSpace;
+    info->dwFreeLinearSpace    = info->dwMaxPagesAvailable;
+    info->dwSwapFilePages      = status.dwTotalPageFile / info->wPageSize;
     return TRUE;
-#else
-    return TRUE;
-#endif
 }
 
 
@@ -897,11 +868,46 @@
  */
 VOID GlobalMemoryStatus( LPMEMORYSTATUS lpmem )
 {
-    /* FIXME: should do something like MemManInfo() here */
+#ifdef linux
+    FILE *f = fopen( "/proc/meminfo", "r" );
+    if (f)
+    {
+        char buffer[256];
+        int total, used, free;
+
+        lpmem->dwTotalPhys = lpmem->dwAvailPhys = 0;
+        lpmem->dwTotalPageFile = lpmem->dwAvailPageFile = 0;
+        while (fgets( buffer, sizeof(buffer), f ))
+        {
+            if (sscanf( buffer, "Mem: %d %d %d", &total, &used, &free ))
+            {
+                lpmem->dwTotalPhys += total;
+                lpmem->dwAvailPhys += free;
+            }
+            else if (sscanf( buffer, "Swap: %d %d %d", &total, &used, &free ))
+            {
+                lpmem->dwTotalPageFile += total;
+                lpmem->dwAvailPageFile += free;
+            }
+        }
+        fclose( f );
+
+        if (lpmem->dwTotalPhys)
+        {
+            lpmem->dwTotalVirtual = lpmem->dwTotalPhys+lpmem->dwTotalPageFile;
+            lpmem->dwAvailVirtual = lpmem->dwAvailPhys+lpmem->dwAvailPageFile;
+            lpmem->dwMemoryLoad = (lpmem->dwTotalVirtual-lpmem->dwAvailVirtual)
+                                      * 100 / lpmem->dwTotalVirtual;
+            return;
+        }
+    }
+#endif
+    /* FIXME: should do something for other systems */
     lpmem->dwMemoryLoad    = 0;
     lpmem->dwTotalPhys     = 16*1024*1024;
     lpmem->dwAvailPhys     = 16*1024*1024;
-    lpmem->dwTotalPageFile = 0;
+    lpmem->dwTotalPageFile = 16*1024*1024;
     lpmem->dwAvailPageFile = 16*1024*1024;
-    lpmem->dwAvailVirtual  = 16*1024*1024;
+    lpmem->dwTotalVirtual  = 32*1024*1024;
+    lpmem->dwAvailVirtual  = 32*1024*1024;
 }
diff --git a/misc/commdlg.c b/misc/commdlg.c
index 0133f88..80aa834 100644
--- a/misc/commdlg.c
+++ b/misc/commdlg.c
@@ -263,8 +263,8 @@
                   lpdis->rcItem.top, str, strlen(str));
 	hMemDC = CreateCompatibleDC(lpdis->hDC);
 	hPrevBitmap = SelectObject32(hMemDC, hBitmap);
-	BitBlt(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
-	       bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
+	BitBlt32(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
+                 bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
 	SelectObject32(hMemDC, hPrevBitmap);
 	DeleteDC(hMemDC);
 	if (lpdis->itemState != 0) InvertRect16(lpdis->hDC, &lpdis->rcItem);
@@ -277,7 +277,7 @@
 	hBrush = SelectObject32(lpdis->hDC, GetStockObject32(LTGRAY_BRUSH));
 	SelectObject32(lpdis->hDC, hBrush);
 	FillRect16(lpdis->hDC, &lpdis->rcItem, hBrush);
-	SendMessage16(lpdis->hwndItem, CB_GETLBTEXT, lpdis->itemID, 
+	SendMessage16(lpdis->hwndItem, CB_GETLBTEXT16, lpdis->itemID, 
                       (LPARAM)SEGPTR_GET(str));
         switch(DRIVE_GetType( str[2] - 'a' ))
         {
@@ -292,8 +292,8 @@
                   lpdis->rcItem.top, str, strlen(str));
 	hMemDC = CreateCompatibleDC(lpdis->hDC);
 	hPrevBitmap = SelectObject32(hMemDC, hBitmap);
-	BitBlt(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
-	       bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
+	BitBlt32( lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
+                  bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY );
 	SelectObject32(hMemDC, hPrevBitmap);
 	DeleteDC(hMemDC);
 	if (lpdis->itemState != 0) InvertRect16(lpdis->hDC, &lpdis->rcItem);
@@ -351,12 +351,12 @@
       while(*pstr)
 	{
 	  dprintf_commdlg(stddeb,"lpstrCustomFilter // add str='%s' ",pstr);
-          i = SendDlgItemMessage16(hWnd, cmb1, CB_ADDSTRING, 0,
+          i = SendDlgItemMessage16(hWnd, cmb1, CB_ADDSTRING16, 0,
                                    (LPARAM)lpofn->lpstrCustomFilter + n );
           n += strlen(pstr) + 1;
 	  pstr += strlen(pstr) + 1;
 	  dprintf_commdlg(stddeb,"associated to '%s'\n", pstr);
-          SendDlgItemMessage16(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
+          SendDlgItemMessage16(hWnd, cmb1, CB_SETITEMDATA16, i, (LPARAM)pstr);
           n += strlen(pstr) + 1;
 	  pstr += strlen(pstr) + 1;
 	}
@@ -367,12 +367,12 @@
 	n = 0;
 	while(*pstr) {
 	  dprintf_commdlg(stddeb,"lpstrFilter // add str='%s' ", pstr);
-	  i = SendDlgItemMessage16(hWnd, cmb1, CB_ADDSTRING, 0,
+	  i = SendDlgItemMessage16(hWnd, cmb1, CB_ADDSTRING16, 0,
 				       (LPARAM)lpofn->lpstrFilter + n );
 	  n += strlen(pstr) + 1;
 	  pstr += strlen(pstr) + 1;
 	  dprintf_commdlg(stddeb,"associated to '%s'\n", pstr);
-	  SendDlgItemMessage16(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
+	  SendDlgItemMessage16(hWnd, cmb1, CB_SETITEMDATA16, i, (LPARAM)pstr);
 	  n += strlen(pstr) + 1;
 	  pstr += strlen(pstr) + 1;
 	}
@@ -380,7 +380,7 @@
   /* set default filter */
   if (lpofn->nFilterIndex == 0 && lpofn->lpstrCustomFilter == (SEGPTR)NULL)
   	lpofn->nFilterIndex = 1;
-  SendDlgItemMessage16(hWnd, cmb1, CB_SETCURSEL, lpofn->nFilterIndex - 1, 0);    
+  SendDlgItemMessage16(hWnd, cmb1, CB_SETCURSEL16, lpofn->nFilterIndex - 1, 0);    
   strncpy(tmpstr, FILEDLG_GetFileType(PTR_SEG_TO_LIN(lpofn->lpstrCustomFilter),
 	     PTR_SEG_TO_LIN(lpofn->lpstrFilter), lpofn->nFilterIndex - 1),511);
   tmpstr[511]=0;
@@ -407,7 +407,7 @@
     fprintf(stderr, "FileDlg: couldn't read initial directory %s!\n", tmpstr);
   /* select current drive in combo 2 */
   n = DRIVE_GetCurrentDrive();
-  SendDlgItemMessage16(hWnd, cmb2, CB_SETCURSEL, n, 0);
+  SendDlgItemMessage16(hWnd, cmb2, CB_SETCURSEL16, n, 0);
   if (!(lpofn->Flags & OFN_SHOWHELP))
     ShowWindow(GetDlgItem(hWnd, pshHelp), SW_HIDE);
   if (lpofn->Flags & OFN_HIDEREADONLY)
@@ -486,18 +486,18 @@
       return TRUE;
     case cmb2: /* disk drop list */
       FILEDLG_StripEditControl(hWnd);
-      lRet = SendDlgItemMessage16(hWnd, cmb2, CB_GETCURSEL, 0, 0L);
+      lRet = SendDlgItemMessage16(hWnd, cmb2, CB_GETCURSEL16, 0, 0L);
       if (lRet == LB_ERR) return 0;
       pstr = SEGPTR_ALLOC(512);
-      SendDlgItemMessage16(hWnd, cmb2, CB_GETLBTEXT, lRet,
+      SendDlgItemMessage16(hWnd, cmb2, CB_GETLBTEXT16, lRet,
                            (LPARAM)SEGPTR_GET(pstr));
       sprintf(tmpstr, "%c:", pstr[2]);
       SEGPTR_FREE(pstr);
     reset_scan:
-      lRet = SendDlgItemMessage16(hWnd, cmb1, CB_GETCURSEL, 0, 0);
+      lRet = SendDlgItemMessage16(hWnd, cmb1, CB_GETCURSEL16, 0, 0);
       if (lRet == LB_ERR)
 	return TRUE;
-      pstr = (LPSTR)SendDlgItemMessage16(hWnd, cmb1, CB_GETITEMDATA, lRet, 0);
+      pstr = (LPSTR)SendDlgItemMessage16(hWnd, cmb1, CB_GETITEMDATA16, lRet, 0);
       dprintf_commdlg(stddeb,"Selected filter : %s\n", pstr);
       SetDlgItemText32A( hWnd, edt1, pstr );
       FILEDLG_ScanDir(hWnd, tmpstr);
@@ -536,7 +536,7 @@
       pstr2 = tmpstr + strlen(tmpstr);
       if (pstr == NULL || *(pstr+1) != 0)
 	strcat(tmpstr, "\\");
-      lRet = SendDlgItemMessage16(hWnd, cmb1, CB_GETCURSEL, 0, 0);
+      lRet = SendDlgItemMessage16(hWnd, cmb1, CB_GETCURSEL16, 0, 0);
       if (lRet == LB_ERR) return TRUE;
       lpofn->nFilterIndex = lRet + 1;
       dprintf_commdlg(stddeb,"commdlg: lpofn->nFilterIndex=%ld\n", lpofn->nFilterIndex);
@@ -1568,10 +1568,10 @@
    point.x=((long)rect.right*(long)x)/(long)MAXHORI;
    point.y=rect.bottom-((long)rect.bottom*(long)y)/(long)MAXVERT;
    if (lpp->oldcross.left!=lpp->oldcross.right)
-     BitBlt(hDC,lpp->oldcross.left,lpp->oldcross.top,
-	     lpp->oldcross.right-lpp->oldcross.left,
-	     lpp->oldcross.bottom-lpp->oldcross.top,
-	     lpp->hdcMem,lpp->oldcross.left,lpp->oldcross.top,SRCCOPY);
+     BitBlt32(hDC,lpp->oldcross.left,lpp->oldcross.top,
+              lpp->oldcross.right-lpp->oldcross.left,
+              lpp->oldcross.bottom-lpp->oldcross.top,
+              lpp->hdcMem,lpp->oldcross.left,lpp->oldcross.top,SRCCOPY);
    lpp->oldcross.left  =point.x-w-1;
    lpp->oldcross.right =point.x+w+1;
    lpp->oldcross.top   =point.y-w-1;
@@ -1652,7 +1652,7 @@
   hDC=GetDC32(hwnd);
   GetClientRect16(hwnd,&rect);
   if (lpp->hdcMem)
-    BitBlt(hDC,0,0,rect.right,rect.bottom,lpp->hdcMem,0,0,SRCCOPY);
+      BitBlt32(hDC,0,0,rect.right,rect.bottom,lpp->hdcMem,0,0,SRCCOPY);
   else
     fprintf(stderr,"choose color: hdcMem is not defined\n");
   ReleaseDC32(hwnd,hDC);
@@ -2285,12 +2285,12 @@
    if (!(nFontType & 0x0004))   /* this means 'TRUETYPE_FONTTYPE' */
      return 1;   
 
-  i=SendMessage16(hwnd,CB_ADDSTRING,0,
+  i=SendMessage16(hwnd,CB_ADDSTRING16,0,
                   (LPARAM)logfont + ((char *)lplf->lfFaceName - (char *)lplf));
   if (i!=CB_ERR)
   {
     w=(lplf->lfCharSet << 8) | lplf->lfPitchAndFamily;
-    SendMessage16(hwnd, CB_SETITEMDATA,i,MAKELONG(nFontType,w));
+    SendMessage16(hwnd, CB_SETITEMDATA16,i,MAKELONG(nFontType,w));
     return 1 ;        /* store some important font information */
   }
   else
@@ -2330,10 +2330,10 @@
          lptm->tmItalic==fontstyles[i].italic)    /* font successful created ? */
      {
        char *str = SEGPTR_STRDUP(fontstyles[i].stname);
-       j=SendMessage16(hwnd,CB_ADDSTRING,0,(LPARAM)SEGPTR_GET(str) );
+       j=SendMessage16(hwnd,CB_ADDSTRING16,0,(LPARAM)SEGPTR_GET(str) );
        SEGPTR_FREE(str);
        if (j==CB_ERR) return 1;
-       j=SendMessage16(hwnd, CB_SETITEMDATA, j, 
+       j=SendMessage16(hwnd, CB_SETITEMDATA16, j, 
                                  MAKELONG(fontstyles[i].weight,fontstyles[i].italic));
        if (j==CB_ERR) return 1;                                 
      }
@@ -2359,11 +2359,11 @@
            ((lpcf->Flags & CF_LIMITSIZE) && (h >= lpcf->nSizeMin) && (h <= lpcf->nSizeMax)))
    {
       sprintf(buffer,"%2d",h);
-      j=SendMessage16(hwnd,CB_FINDSTRING,-1,(LPARAM)SEGPTR_GET(buffer));
+      j=SendMessage16(hwnd,CB_FINDSTRING16,-1,(LPARAM)SEGPTR_GET(buffer));
       if (j==CB_ERR)
       {
-        j=SendMessage16(hwnd,CB_ADDSTRING,0,(LPARAM)SEGPTR_GET(buffer));
-        if (j!=CB_ERR) j = SendMessage16(hwnd, CB_SETITEMDATA, j, h); 
+        j=SendMessage16(hwnd,CB_ADDSTRING16,0,(LPARAM)SEGPTR_GET(buffer));
+        if (j!=CB_ERR) j = SendMessage16(hwnd, CB_SETITEMDATA16, j, h); 
         if (j==CB_ERR)
         {
             SEGPTR_FREE(buffer);
@@ -2400,7 +2400,7 @@
   if (SetFontSizesToCombo3(hcmb3, lplf ,lpcf))
    return 0;
 
-  if (!SendMessage16(hcmb2,CB_GETCOUNT,0,0))
+  if (!SendMessage16(hcmb2,CB_GETCOUNT16,0,0))
   {
        HDC32 hdc= (lpcf->Flags & CF_PRINTERFONTS && lpcf->hDC) ? lpcf->hDC : GetDC32(hDlg);
        i=SetFontStylesToCombo2(hcmb2,hdc,lplf,lptm);
@@ -2450,12 +2450,12 @@
       /* FIXME: load color name from resource:  res=LoadString(...,i+....,buffer,.....); */
       char *name = SEGPTR_ALLOC(20);
       strcpy( name, "[color name]" );
-      j=SendDlgItemMessage16(hDlg,cmb4,CB_ADDSTRING,0,(LPARAM)SEGPTR_GET(name));
+      j=SendDlgItemMessage16(hDlg,cmb4,CB_ADDSTRING16,0,(LPARAM)SEGPTR_GET(name));
       SEGPTR_FREE(name);
-      SendDlgItemMessage16(hDlg,cmb4, CB_SETITEMDATA,j,textcolors[j]);
+      SendDlgItemMessage16(hDlg,cmb4, CB_SETITEMDATA16,j,textcolors[j]);
       /* look for a fitting value in color combobox */
       if (textcolors[j]==lpcf->rgbColors)
-        SendDlgItemMessage16(hDlg,cmb4, CB_SETCURSEL,j,0);
+        SendDlgItemMessage16(hDlg,cmb4, CB_SETCURSEL16,j,0);
     }
   }
   else
@@ -2469,45 +2469,45 @@
   hdc= (lpcf->Flags & CF_PRINTERFONTS && lpcf->hDC) ? lpcf->hDC : GetDC32(hDlg);
   if (hdc)
   {
-    if (!EnumFontFamilies (hdc, NULL,FontFamilyEnumProc,(LPARAM)GetDlgItem(hDlg,cmb1)))
+    if (!EnumFontFamilies16(hdc, NULL,FontFamilyEnumProc,(LPARAM)GetDlgItem(hDlg,cmb1)))
       dprintf_commdlg(stddeb,"WM_INITDIALOG: EnumFontFamilies returns 0\n");
     if (lpcf->Flags & CF_INITTOLOGFONTSTRUCT)
     {
       /* look for fitting font name in combobox1 */
-      j=SendDlgItemMessage16(hDlg,cmb1,CB_FINDSTRING,-1,(LONG)lpxx->lfFaceName);
+      j=SendDlgItemMessage16(hDlg,cmb1,CB_FINDSTRING16,-1,(LONG)lpxx->lfFaceName);
       if (j!=CB_ERR)
       {
-        SendDlgItemMessage16(hDlg,cmb1,CB_SETCURSEL,j,0);
+        SendDlgItemMessage16(hDlg,cmb1,CB_SETCURSEL16,j,0);
 	SendMessage16(hDlg,WM_COMMAND,cmb1,MAKELONG(GetDlgItem(hDlg,cmb1),CBN_SELCHANGE));
         init=1;
         /* look for fitting font style in combobox2 */
         l=MAKELONG(lpxx->lfWeight > FW_MEDIUM ? FW_BOLD:FW_NORMAL,lpxx->lfItalic !=0);
         for (i=0;i<TEXT_EXTRAS;i++)
         {
-          if (l==SendDlgItemMessage16(hDlg,cmb2, CB_GETITEMDATA,i,0))
-            SendDlgItemMessage16(hDlg,cmb2,CB_SETCURSEL,i,0);
+          if (l==SendDlgItemMessage16(hDlg,cmb2, CB_GETITEMDATA16,i,0))
+            SendDlgItemMessage16(hDlg,cmb2,CB_SETCURSEL16,i,0);
         }
       
         /* look for fitting font size in combobox3 */
-        j=SendDlgItemMessage16(hDlg,cmb3,CB_GETCOUNT,0,0);
+        j=SendDlgItemMessage16(hDlg,cmb3,CB_GETCOUNT16,0,0);
         for (i=0;i<j;i++)
         {
-          if (lpxx->lfHeight==(int)SendDlgItemMessage16(hDlg,cmb3, CB_GETITEMDATA,i,0))
-            SendDlgItemMessage16(hDlg,cmb3,CB_SETCURSEL,i,0);
+          if (lpxx->lfHeight==(int)SendDlgItemMessage16(hDlg,cmb3, CB_GETITEMDATA16,i,0))
+            SendDlgItemMessage16(hDlg,cmb3,CB_SETCURSEL16,i,0);
         }
       }
       if (!init)
       {
-        SendDlgItemMessage16(hDlg,cmb1,CB_SETCURSEL,0,0);
+        SendDlgItemMessage16(hDlg,cmb1,CB_SETCURSEL16,0,0);
 	SendMessage16(hDlg,WM_COMMAND,cmb1,MAKELONG(GetDlgItem(hDlg,cmb1),CBN_SELCHANGE));      
       }
     }
     if (lpcf->Flags & CF_USESTYLE && lpcf->lpszStyle)
     {
-      j=SendDlgItemMessage16(hDlg,cmb2,CB_FINDSTRING,-1,(LONG)lpcf->lpszStyle);
+      j=SendDlgItemMessage16(hDlg,cmb2,CB_FINDSTRING16,-1,(LONG)lpcf->lpszStyle);
       if (j!=CB_ERR)
       {
-        j=SendDlgItemMessage16(hDlg,cmb2,CB_SETCURSEL,j,0);
+        j=SendDlgItemMessage16(hDlg,cmb2,CB_SETCURSEL16,j,0);
         SendMessage16(hDlg,WM_COMMAND,cmb2,MAKELONG(GetDlgItem(hDlg,cmb2),CBN_SELCHANGE));
       }
     }
@@ -2580,20 +2580,20 @@
    switch (lpdi->CtlID)
    {
     case cmb1:	/* dprintf_commdlg(stddeb,"WM_Drawitem cmb1\n"); */
-		SendMessage16(lpdi->hwndItem, CB_GETLBTEXT, lpdi->itemID,
+		SendMessage16(lpdi->hwndItem, CB_GETLBTEXT16, lpdi->itemID,
 			(LPARAM)SEGPTR_GET(buffer));	          
 		GetObject16( hBitmapTT, sizeof(bm), &bm );
 		TextOut16(lpdi->hDC, lpdi->rcItem.left + bm.bmWidth + 10,
                           lpdi->rcItem.top, buffer, lstrlen16(buffer));
 #if 0
-		nFontType = SendMessage16(lpdi->hwndItem, CB_GETITEMDATA, lpdi->itemID,0L);
+		nFontType = SendMessage16(lpdi->hwndItem, CB_GETITEMDATA16, lpdi->itemID,0L);
 		  /* FIXME: draw bitmap if truetype usage */
 		if (nFontType&TRUETYPE_FONTTYPE)
 		{
 		  hMemDC = CreateCompatibleDC(lpdi->hDC);
 		  hBitmap = SelectObject32(hMemDC, hBitmapTT);
-		  BitBlt(lpdi->hDC, lpdi->rcItem.left, lpdi->rcItem.top,
-			bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
+		  BitBlt32(lpdi->hDC, lpdi->rcItem.left, lpdi->rcItem.top,
+                           bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
 		  SelectObject32(hMemDC, hBitmap);
 		  DeleteDC(hMemDC);
 		}
@@ -2601,18 +2601,18 @@
 		break;
     case cmb2:
     case cmb3:	/* dprintf_commdlg(stddeb,"WM_DRAWITEN cmb2,cmb3\n"); */
-		SendMessage16(lpdi->hwndItem, CB_GETLBTEXT, lpdi->itemID,
+		SendMessage16(lpdi->hwndItem, CB_GETLBTEXT16, lpdi->itemID,
 			(LPARAM)SEGPTR_GET(buffer));
 		TextOut16(lpdi->hDC, lpdi->rcItem.left,
                           lpdi->rcItem.top, buffer, lstrlen16(buffer));
 		break;
 
     case cmb4:	/* dprintf_commdlg(stddeb,"WM_DRAWITEM cmb4 (=COLOR)\n"); */
-		SendMessage16(lpdi->hwndItem, CB_GETLBTEXT, lpdi->itemID,
+		SendMessage16(lpdi->hwndItem, CB_GETLBTEXT16, lpdi->itemID,
     		    (LPARAM)SEGPTR_GET(buffer));
 		TextOut16(lpdi->hDC, lpdi->rcItem.left +  25+5,
                           lpdi->rcItem.top, buffer, lstrlen16(buffer));
-		cr = SendMessage16(lpdi->hwndItem, CB_GETITEMDATA, lpdi->itemID,0L);
+		cr = SendMessage16(lpdi->hwndItem, CB_GETITEMDATA16, lpdi->itemID,0L);
 		hBrush = CreateSolidBrush32(cr);
 		if (hBrush)
 		{
@@ -2674,17 +2674,17 @@
 		    hdc=(lpcf->Flags & CF_PRINTERFONTS && lpcf->hDC) ? lpcf->hDC : GetDC32(hDlg);
 		    if (hdc)
 		    {
-                      SendDlgItemMessage16(hDlg,cmb2,CB_RESETCONTENT,0,0); 
-		      SendDlgItemMessage16(hDlg,cmb3,CB_RESETCONTENT,0,0);
-		      i=SendDlgItemMessage16(hDlg,cmb1,CB_GETCURSEL,0,0);
+                      SendDlgItemMessage16(hDlg,cmb2,CB_RESETCONTENT16,0,0); 
+		      SendDlgItemMessage16(hDlg,cmb3,CB_RESETCONTENT16,0,0);
+		      i=SendDlgItemMessage16(hDlg,cmb1,CB_GETCURSEL16,0,0);
 		      if (i!=CB_ERR)
 		      {
 		        HCURSOR16 hcursor=SetCursor(LoadCursor16(0,IDC_WAIT));
                         char *str = SEGPTR_ALLOC(256);
-                        SendDlgItemMessage16(hDlg,cmb1,CB_GETLBTEXT,i,
+                        SendDlgItemMessage16(hDlg,cmb1,CB_GETLBTEXT16,i,
                                              (LPARAM)SEGPTR_GET(str));
 	                dprintf_commdlg(stddeb,"WM_COMMAND/cmb1 =>%s\n",str);
-       		        EnumFontFamilies(hdc,str,FontStyleEnumProc,
+       		        EnumFontFamilies16(hdc,str,FontStyleEnumProc,
 		             MAKELONG(GetDlgItem(hDlg,cmb2),GetDlgItem(hDlg,cmb3)));
 		        SetCursor(hcursor);     
                         SEGPTR_FREE(str);
@@ -2706,14 +2706,14 @@
 	          {
                     char *str = SEGPTR_ALLOC(256);
                     dprintf_commdlg(stddeb,"WM_COMMAND/cmb2,3 =%08lX\n", lParam);
-		    i=SendDlgItemMessage16(hDlg,cmb1,CB_GETCURSEL,0,0);
+		    i=SendDlgItemMessage16(hDlg,cmb1,CB_GETCURSEL16,0,0);
 		    if (i==CB_ERR)
                       i=GetDlgItemText32A( hDlg, cmb1, str, 256 );
                     else
                     {
-		      SendDlgItemMessage16(hDlg,cmb1,CB_GETLBTEXT,i,
+		      SendDlgItemMessage16(hDlg,cmb1,CB_GETLBTEXT16,i,
                                            (LPARAM)SEGPTR_GET(str));
-		      l=SendDlgItemMessage16(hDlg,cmb1,CB_GETITEMDATA,i,0);
+		      l=SendDlgItemMessage16(hDlg,cmb1,CB_GETITEMDATA16,i,0);
 		      j=HIWORD(l);
 		      lpcf->nFontType = LOWORD(l);
 		      /* FIXME:   lpcf->nFontType |= ....  SIMULATED_FONTTYPE and so */
@@ -2724,18 +2724,18 @@
                     }
                     strcpy(lpxx->lfFaceName,str);
                     SEGPTR_FREE(str);
-		    i=SendDlgItemMessage16(hDlg,cmb2,CB_GETCURSEL,0,0);
+		    i=SendDlgItemMessage16(hDlg,cmb2,CB_GETCURSEL16,0,0);
 		    if (i!=CB_ERR)
 		    {
-		      l=SendDlgItemMessage16(hDlg,cmb2,CB_GETITEMDATA,i,0);
+		      l=SendDlgItemMessage16(hDlg,cmb2,CB_GETITEMDATA16,i,0);
 		      if (0!=(lpxx->lfItalic=HIWORD(l)))
 		        lpcf->nFontType |= ITALIC_FONTTYPE;
 		      if ((lpxx->lfWeight=LOWORD(l)) > FW_MEDIUM)
 		        lpcf->nFontType |= BOLD_FONTTYPE;
 		    }
-		    i=SendDlgItemMessage16(hDlg,cmb3,CB_GETCURSEL,0,0);
+		    i=SendDlgItemMessage16(hDlg,cmb3,CB_GETCURSEL16,0,0);
 		    if (i!=CB_ERR)
-		      lpxx->lfHeight=-LOWORD(SendDlgItemMessage16(hDlg,cmb3,CB_GETITEMDATA,i,0));
+		      lpxx->lfHeight=-LOWORD(SendDlgItemMessage16(hDlg,cmb3,CB_GETITEMDATA16,i,0));
 		    else
 		      lpxx->lfHeight=0;
 		    lpxx->lfStrikeOut=IsDlgButtonChecked(hDlg,chx1);
@@ -2753,7 +2753,7 @@
                   }
                   break;
 
-	case cmb4:i=SendDlgItemMessage16(hDlg,cmb4,CB_GETCURSEL,0,0);
+	case cmb4:i=SendDlgItemMessage16(hDlg,cmb4,CB_GETCURSEL16,0,0);
 		  if (i!=CB_ERR)
 		  {
 		   lpcf->rgbColors=textcolors[i];
diff --git a/misc/crtdll.c b/misc/crtdll.c
index 4917a4e..e7a8be6 100644
--- a/misc/crtdll.c
+++ b/misc/crtdll.c
@@ -20,6 +20,7 @@
 #include "debug.h"
 #include "module.h"
 #include "xmalloc.h"
+#include "heap.h"
 
 UINT32 CRTDLL_argc_dll;         /* CRTDLL.23 */
 LPSTR *CRTDLL_argv_dll;         /* CRTDLL.24 */
@@ -141,6 +142,14 @@
 }
 
 /*********************************************************************
+ *                  sprintf        (CRTDLL.458)
+ */
+int CRTDLL_sprintf(DWORD *args)
+{
+	return vsprintf((LPSTR)(args[0]),(LPSTR)(args[1]),args+2);
+}
+
+/*********************************************************************
  *                  time          (CRTDLL.488)
  */
 time_t CRTDLL_time(time_t *timeptr)
@@ -613,3 +622,20 @@
 {
     HeapFree(GetProcessHeap(),0,ptr);
 }
+
+/*********************************************************************
+ *                  _strdup          (CRTDLL.285)
+ */
+LPSTR CRTDLL__strdup(LPSTR ptr)
+{
+    return HEAP_strdupA(GetProcessHeap(),0,ptr);
+}
+
+/*********************************************************************
+ *                  fclose           (CRTDLL.362)
+ */
+DWORD CRTDLL_fclose(LPVOID x)
+{
+    dprintf_crtdll(stdnimp,"fclose(%p)\n",x);
+    return 0;
+}
diff --git a/misc/exec.c b/misc/exec.c
index 5594182..c69416d 100644
--- a/misc/exec.c
+++ b/misc/exec.c
@@ -113,7 +113,10 @@
 	}
 	hDest = FindWindow32A( "MS_WINHELP", NULL );
 	if(!hDest)
-		return FALSE;
+		if(wCommand == HELP_QUIT)
+			return TRUE;
+		else
+			return FALSE;
 	switch(wCommand)
 	{
 		case HELP_CONTEXT:
diff --git a/misc/registry.c b/misc/registry.c
index b5ba088..cdd6751 100644
--- a/misc/registry.c
+++ b/misc/registry.c
@@ -20,6 +20,7 @@
 #include "win.h"
 #include "winerror.h"
 #include "file.h"
+#include "dos_fs.h"
 #include "string32.h"	
 #include "stddebug.h"
 #include "debug.h"
@@ -1054,8 +1055,6 @@
 	return NULL;
 }
 
-extern time_t FileTimeToUnixTime(FILETIME*);
-
 static void
 _w95_loadreg(char* fn,LPKEYSTRUCT lpkey) {
 	/* Disk Key Entry structure (RGKN part) */
@@ -1211,7 +1210,7 @@
 	if (!GetFileInformationByHandle(hfd,&hfdinfo))
 		return;
 	end		= hfdinfo.nFileSizeLow;
-	lastmodified	= FileTimeToUnixTime(&(hfdinfo.ftLastWriteTime));
+	lastmodified	= DOSFS_FileTimeToUnixTime(&(hfdinfo.ftLastWriteTime));
 
 	if (-1==_llseek(hfd,rgdbsection,SEEK_SET))
 		return;
diff --git a/misc/shell.c b/misc/shell.c
index 3bec8c7..3a96897 100644
--- a/misc/shell.c
+++ b/misc/shell.c
@@ -79,11 +79,8 @@
 		hDrop,wFile,lpszFile,wLength);
     
     lpDropFileStruct = (LPDROPFILESTRUCT) GlobalLock16(hDrop); 
-    if(!lpDropFileStruct)
-    {
-	dprintf_reg(stddeb,"DragQueryFile: unable to lock handle!\n");
-	return 0;
-    } 
+    if(!lpDropFileStruct) return 0;
+
     lpCurrent = (LPSTR) lpDropFileStruct + lpDropFileStruct->wSize;
     
     i = 0;
@@ -100,7 +97,7 @@
     i = (wLength > i) ? i : wLength-1;
     strncpy(lpszFile, lpCurrent, i);
     lpszFile[i] = '\0';
-    
+
     GlobalUnlock16(hDrop);
     return i;
 }
@@ -121,7 +118,7 @@
 BOOL DragQueryPoint(HDROP16 hDrop, POINT16 *p)
 {
     LPDROPFILESTRUCT lpDropFileStruct;  
-    BOOL             bRet;
+    BOOL16           bRet;
 
     lpDropFileStruct = (LPDROPFILESTRUCT) GlobalLock16(hDrop);
 
@@ -807,7 +804,7 @@
  */
 int RegisterShellHook(void *ptr) 
 {
-	dprintf_reg(stdnimp, "RegisterShellHook : Empty Stub !!!\n");
+	fprintf(stdnimp, "RegisterShellHook : Empty Stub !!!\n");
 	return 0;
 }
 
@@ -817,7 +814,7 @@
  */
 int ShellHookProc(void) 
 {
-	dprintf_reg(stdnimp, "ShellHookProc : Empty Stub !!!\n");
+	fprintf(stdnimp, "ShellHookProc : Empty Stub !!!\n");
         return 0;
 }
 
diff --git a/misc/spy.c b/misc/spy.c
index 3cdf52d..57ce9d9 100644
--- a/misc/spy.c
+++ b/misc/spy.c
@@ -215,15 +215,43 @@
     NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 
     /* 0x0140 - Win32 Comboboxes */
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+    "CB_GETEDITSEL32",          /* 0x0140 */
+    "CB_LIMITTEXT32",           /* 0x0141 */
+    "CB_SETEDITSEL32",          /* 0x0142 */
+    "CB_ADDSTRING32",           /* 0x0143 */
+    "CB_DELETESTRING32",        /* 0x0144 */
+    "CB_DIR32",                 /* 0x0145 */
+    "CB_GETCOUNT32",            /* 0x0146 */
+    "CB_GETCURSEL32",           /* 0x0147 */
+    "CB_GETLBTEXT32",           /* 0x0148 */
+    "CB_GETLBTEXTLEN32",        /* 0x0149 */
+    "CB_INSERTSTRING32",        /* 0x014a */
+    "CB_RESETCONTENT32",        /* 0x014b */
+    "CB_FINDSTRING32",          /* 0x014c */
+    "CB_SELECTSTRING32",        /* 0x014d */
+    "CB_SETCURSEL32",           /* 0x014e */
+    "CB_SHOWDROPDOWN32",        /* 0x014f */
 
-    /* 0x0150 */
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+    "CB_GETITEMDATA32",         /* 0x0150 */
+    "CB_SETITEMDATA32",         /* 0x0151 */
+    "CB_GETDROPPEDCONTROLRECT32",/* 0x0152 */
+    "CB_SETITEMHEIGHT32",       /* 0x0153 */
+    "CB_GETITEMHEIGHT32",       /* 0x0154 */
+    "CB_SETEXTENDEDUI32",       /* 0x0155 */
+    "CB_GETEXTENDEDUI32",       /* 0x0156 */
+    "CB_GETDROPPEDSTATE32",     /* 0x0157 */
+    "CB_FINDSTRINGEXACT32",     /* 0x0158 */
+    "CB_SETLOCALE32",           /* 0x0159 */
+    "CB_GETLOCALE32",           /* 0x015a */
+    "CB_GETTOPINDEX32",         /* 0x015b */
+    "CB_SETTOPINDEX32",         /* 0x015c */
+    "CB_GETHORIZONTALEXTENT32", /* 0x015d */
+    "CB_SETHORIZONTALEXTENT32", /* 0x015e */
+    "CB_GETDROPPEDWIDTH32",     /* 0x015f */
 
-    /* 0x0160 */
-    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+    "CB_SETDROPPEDWIDTH32",     /* 0x0160 */
+    "CB_INITSTORAGE32",         /* 0x0161 */
+    NULL, NULL, NULL, NULL, NULL, NULL,
     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 
     /* 0x0170 - Win32 Static controls */
diff --git a/miscemu/int21.c b/miscemu/int21.c
index d701a8b..1a4cc96 100644
--- a/miscemu/int21.c
+++ b/miscemu/int21.c
@@ -15,10 +15,10 @@
 #include <unistd.h>
 #include <utime.h>
 #include <ctype.h>
+#include "windows.h"
 #include "dos_fs.h"
 #include "drive.h"
 #include "file.h"
-#include "windows.h"
 #include "msdos.h"
 #include "ldt.h"
 #include "task.h"
diff --git a/objects/Makefile.in b/objects/Makefile.in
index 56b3307..953c68d 100644
--- a/objects/Makefile.in
+++ b/objects/Makefile.in
@@ -6,7 +6,6 @@
 MODULE    = objects
 
 C_SRCS = \
-	bitblt.c \
 	bitmap.c \
 	brush.c \
 	clipping.c \
diff --git a/objects/color.c b/objects/color.c
index d5afb9d..bc1615f 100644
--- a/objects/color.c
+++ b/objects/color.c
@@ -482,9 +482,10 @@
     /* Build free list */
 
     if( COLOR_firstFree != -1 )
+    {
 	COLOR_FormatSystemPalette();
-
-    COLOR_FillDefaultColors();
+        COLOR_FillDefaultColors();
+    }
 
     /* create default palette (20 system colors) */
 
diff --git a/objects/cursoricon.c b/objects/cursoricon.c
index a3388af..df7be52 100644
--- a/objects/cursoricon.c
+++ b/objects/cursoricon.c
@@ -25,6 +25,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include "windows.h"
+#include "color.h"
 #include "bitmap.h"
 #include "callback.h"
 #include "cursoricon.h"
@@ -430,34 +431,86 @@
 /***********************************************************************
  *           CURSORICON_IconToCursor
  *
- * Should convert bitmap to mono and truncate if too large
- * FIXME: if icon is passed returns a copy of OCR_DRAGOBJECT cursor
- *	  but should actually convert icon to cursor.
+ * Converts bitmap to mono and truncates if icon is too large
  */
-HCURSOR16 CURSORICON_IconToCursor(HICON16 hIcon)
+HCURSOR16 CURSORICON_IconToCursor(HICON16 hIcon, BOOL32 bSemiTransparent)
 {
+ HCURSOR16       hRet = 0;
  CURSORICONINFO *ptr = NULL;
+ HTASK16 	 hTask = GetCurrentTask();
+ TDB*  		 pTask = (TDB *)GlobalLock16(hTask);
 
  if(hIcon)
     if (!(ptr = (CURSORICONINFO*)GlobalLock16( hIcon ))) return FALSE;
        if (ptr->bPlanes * ptr->bBitsPerPixel == 1)
+           hRet = CURSORICON_Copy( pTask->hInstance, hIcon );
+       else
           {
-            return hIcon; /* assuming it's a cursor */
+           BYTE  pAndBits[128];
+           BYTE  pXorBits[128];
+	   int   x, y, ix, iy, shift; 
+	   int   bpp = (ptr->bBitsPerPixel>=24)?32:ptr->bBitsPerPixel; /* this sucks */
+           BYTE* psPtr = (BYTE *)(ptr + 1) +
+                            ptr->nHeight * BITMAP_WIDTH_BYTES(ptr->nWidth,1);
+           BYTE* pxbPtr = pXorBits;
+           unsigned *psc = NULL, val = 0;
+           unsigned val_base = 0xffffffff >> (32 - bpp);
+           BYTE* pbc = NULL;
+
+           COLORREF       col;
+           CURSORICONINFO cI;
+
+           if(!pTask) return 0;
+
+           memset(pXorBits, 0, 128);
+           cI.bBitsPerPixel = 1; cI.bPlanes = 1;
+           cI.ptHotSpot.x = cI.ptHotSpot.y = 15;
+           cI.nWidth = 32; cI.nHeight = 32;
+           cI.nWidthBytes = 4;	/* 1bpp */
+
+           x = (ptr->nWidth > 32) ? 32 : ptr->nWidth;
+           y = (ptr->nHeight > 32) ? 32 : ptr->nHeight;
+
+           for( iy = 0; iy < y; iy++ )
+           {
+              val = BITMAP_WIDTH_BYTES( ptr->nWidth, 1 );
+              memcpy( pAndBits + iy * 4,
+                     (BYTE *)(ptr + 1) + iy * val, (val>4) ? 4 : val);
+              shift = iy % 2;
+
+              for( ix = 0; ix < x; ix++ )
+              {
+                if( bSemiTransparent && ((ix+shift)%2) )
+                {
+                    pbc = pAndBits + iy * 4 + ix/8;
+                   *pbc |= 0x80 >> (ix%8);
+                }
+                else
+                {
+                  psc = (unsigned*)(psPtr + (ix * bpp)/8);
+                  val = ((*psc) >> (ix * bpp)%8) & val_base;
+                  col = COLOR_ToLogical(val);
+                  if( GetRValue(col) > 0xa0 ||
+                      GetGValue(col) > 0x80 ||
+                      GetBValue(col) > 0xa0 )
+                  {
+                    pbc = pxbPtr + ix/8;
+                   *pbc |= 0x80 >> (ix%8);
+                  }
+                }
+              }
+              psPtr += ptr->nWidthBytes;
+              pxbPtr += 4;
+           }
+           hRet = CreateCursorIconIndirect( pTask->hInstance , &cI, pAndBits, pXorBits);
+
+           if( !hRet ) /* fall back on default drag cursor */
+                hRet = CURSORICON_Copy( pTask->hInstance ,
+                              CURSORICON_Load(0,MAKEINTRESOURCE(OCR_DRAGOBJECT),
+                                         SYSMETRICS_CXCURSOR, SYSMETRICS_CYCURSOR, 1, TRUE) );
           }
-       else 
-	  {
-	   /* kludge */
-	   TDB* pTask = (TDB *)GlobalLock16( GetCurrentTask() );
 
-	   if(!pTask) return 0;
-
-           fprintf( stdnimp, "IconToCursor: Icons are not supported, returning default!\n");
-	   return CURSORICON_Copy( pTask->hInstance ,
-				   CURSORICON_Load(0,MAKEINTRESOURCE(OCR_DRAGOBJECT),
-				                   SYSMETRICS_CXCURSOR, SYSMETRICS_CYCURSOR, 1, TRUE) );
-	  }
-
- return 0;
+ return hRet;
 }
 
 /***********************************************************************
@@ -627,9 +680,9 @@
     if (hXorBits && hAndBits)
     {
         HBITMAP32 hBitTemp = SelectObject32( hMemDC, hAndBits );
-        BitBlt( hdc, x, y, ptr->nWidth, ptr->nHeight, hMemDC, 0, 0, SRCAND );
+        BitBlt32( hdc, x, y, ptr->nWidth, ptr->nHeight, hMemDC, 0, 0, SRCAND );
         SelectObject32( hMemDC, hXorBits );
-        BitBlt( hdc, x, y, ptr->nWidth, ptr->nHeight, hMemDC, 0, 0, SRCINVERT);
+        BitBlt32(hdc, x, y, ptr->nWidth, ptr->nHeight, hMemDC, 0, 0,SRCINVERT);
         SelectObject32( hMemDC, hBitTemp );
     }
     DeleteDC( hMemDC );
@@ -896,8 +949,8 @@
 	pt->x = pt->y = 0;
     else
     {
-	pt->x = rootX + desktopX;
-	pt->y = rootY + desktopY;
+	pt->x = childX;
+	pt->y = childY;
     }
     dprintf_cursor(stddeb, "GetCursorPos: ret=%d,%d\n", pt->x, pt->y );
 }
diff --git a/objects/dib.c b/objects/dib.c
index 8ec1ce1..7a4fcf0 100644
--- a/objects/dib.c
+++ b/objects/dib.c
@@ -633,8 +633,8 @@
                               bits, info, wUsage );
     hdcMem = CreateCompatibleDC( hdc );
     hOldBitmap = SelectObject32( hdcMem, hBitmap );
-    StretchBlt( hdc, xDest, yDest, wDestWidth, wDestHeight,
-                hdcMem, xSrc, ySrc, wSrcWidth, wSrcHeight, dwRop );
+    StretchBlt32( hdc, xDest, yDest, wDestWidth, wDestHeight,
+                  hdcMem, xSrc, ySrc, wSrcWidth, wSrcHeight, dwRop );
     SelectObject32( hdcMem, hOldBitmap );
     DeleteDC( hdcMem );
     DeleteObject32( hBitmap );
diff --git a/objects/font.c b/objects/font.c
index 0c4f2fe..df3b109 100644
--- a/objects/font.c
+++ b/objects/font.c
@@ -339,6 +339,78 @@
     return (DWORD)-1; /* failure */
 }
 
+void
+FONT_LOGFONT32AToLOGFONT16(const LOGFONT32A *font,LPLOGFONT16 font16) {
+    font16->lfHeight         = (INT16)font->lfHeight;
+    font16->lfWidth          = (INT16)font->lfWidth;
+    font16->lfEscapement     = (INT16)font->lfEscapement;
+    font16->lfOrientation    = (INT16)font->lfOrientation;
+    font16->lfWeight         = (INT16)font->lfWeight;
+    font16->lfItalic         = font->lfItalic;
+    font16->lfUnderline      = font->lfUnderline;
+    font16->lfStrikeOut      = font->lfStrikeOut;
+    font16->lfCharSet        = font->lfCharSet;
+    font16->lfOutPrecision   = font->lfOutPrecision;
+    font16->lfClipPrecision  = font->lfClipPrecision;
+    font16->lfQuality        = font->lfQuality;
+    font16->lfPitchAndFamily = font->lfPitchAndFamily;
+    lstrcpyn32A( font16->lfFaceName, font->lfFaceName, LF_FACESIZE );
+}
+
+void
+FONT_LOGFONT32WToLOGFONT16(const LOGFONT32W *font,LPLOGFONT16 font16) {
+    font16->lfHeight         = (INT16)font->lfHeight;
+    font16->lfWidth          = (INT16)font->lfWidth;
+    font16->lfEscapement     = (INT16)font->lfEscapement;
+    font16->lfOrientation    = (INT16)font->lfOrientation;
+    font16->lfWeight         = (INT16)font->lfWeight;
+    font16->lfItalic         = font->lfItalic;
+    font16->lfUnderline      = font->lfUnderline;
+    font16->lfStrikeOut      = font->lfStrikeOut;
+    font16->lfCharSet        = font->lfCharSet;
+    font16->lfOutPrecision   = font->lfOutPrecision;
+    font16->lfClipPrecision  = font->lfClipPrecision;
+    font16->lfQuality        = font->lfQuality;
+    font16->lfPitchAndFamily = font->lfPitchAndFamily;
+    lstrcpynWtoA( font16->lfFaceName, font->lfFaceName, LF_FACESIZE );
+}
+
+void
+FONT_LOGFONT16ToLOGFONT32A(LPLOGFONT16 font,LPLOGFONT32A font32A) {
+    font32A->lfHeight         = (INT32)font->lfHeight;
+    font32A->lfWidth          = (INT32)font->lfWidth;
+    font32A->lfEscapement     = (INT32)font->lfEscapement;
+    font32A->lfOrientation    = (INT32)font->lfOrientation;
+    font32A->lfWeight         = (INT32)font->lfWeight;
+    font32A->lfItalic         = font->lfItalic;
+    font32A->lfUnderline      = font->lfUnderline;
+    font32A->lfStrikeOut      = font->lfStrikeOut;
+    font32A->lfCharSet        = font->lfCharSet;
+    font32A->lfOutPrecision   = font->lfOutPrecision;
+    font32A->lfClipPrecision  = font->lfClipPrecision;
+    font32A->lfQuality        = font->lfQuality;
+    font32A->lfPitchAndFamily = font->lfPitchAndFamily;
+    lstrcpyn32A( font32A->lfFaceName, font->lfFaceName, LF_FACESIZE );
+}
+
+void
+FONT_LOGFONT16ToLOGFONT32W(LPLOGFONT16 font,LPLOGFONT32W font32W) {
+    font32W->lfHeight         = (INT32)font->lfHeight;
+    font32W->lfWidth          = (INT32)font->lfWidth;
+    font32W->lfEscapement     = (INT32)font->lfEscapement;
+    font32W->lfOrientation    = (INT32)font->lfOrientation;
+    font32W->lfWeight         = (INT32)font->lfWeight;
+    font32W->lfItalic         = font->lfItalic;
+    font32W->lfUnderline      = font->lfUnderline;
+    font32W->lfStrikeOut      = font->lfStrikeOut;
+    font32W->lfCharSet        = font->lfCharSet;
+    font32W->lfOutPrecision   = font->lfOutPrecision;
+    font32W->lfClipPrecision  = font->lfClipPrecision;
+    font32W->lfQuality        = font->lfQuality;
+    font32W->lfPitchAndFamily = font->lfPitchAndFamily;
+    lstrcpynAtoW( font32W->lfFaceName, font->lfFaceName, LF_FACESIZE );
+}
+
 
 /***********************************************************************
  *           CreateScalableFontResource    (GDI.310)
@@ -387,20 +459,8 @@
 {
     LOGFONT16 font16;
 
-    font16.lfHeight         = (INT16)font->lfHeight;
-    font16.lfWidth          = (INT16)font->lfWidth;
-    font16.lfEscapement     = (INT16)font->lfEscapement;
-    font16.lfOrientation    = (INT16)font->lfOrientation;
-    font16.lfWeight         = (INT16)font->lfWeight;
-    font16.lfItalic         = font->lfItalic;
-    font16.lfUnderline      = font->lfUnderline;
-    font16.lfStrikeOut      = font->lfStrikeOut;
-    font16.lfCharSet        = font->lfCharSet;
-    font16.lfOutPrecision   = font->lfOutPrecision;
-    font16.lfClipPrecision  = font->lfClipPrecision;
-    font16.lfQuality        = font->lfQuality;
-    font16.lfPitchAndFamily = font->lfPitchAndFamily;
-    lstrcpyn32A( font16.lfFaceName, font->lfFaceName, LF_FACESIZE );
+    FONT_LOGFONT32AToLOGFONT16(font,&font16);
+
     return CreateFontIndirect16( &font16 );
 }
 
@@ -412,20 +472,7 @@
 {
     LOGFONT16 font16;
 
-    font16.lfHeight         = (INT16)font->lfHeight;
-    font16.lfWidth          = (INT16)font->lfWidth;
-    font16.lfEscapement     = (INT16)font->lfEscapement;
-    font16.lfOrientation    = (INT16)font->lfOrientation;
-    font16.lfWeight         = (INT16)font->lfWeight;
-    font16.lfItalic         = font->lfItalic;
-    font16.lfUnderline      = font->lfUnderline;
-    font16.lfStrikeOut      = font->lfStrikeOut;
-    font16.lfCharSet        = font->lfCharSet;
-    font16.lfOutPrecision   = font->lfOutPrecision;
-    font16.lfClipPrecision  = font->lfClipPrecision;
-    font16.lfQuality        = font->lfQuality;
-    font16.lfPitchAndFamily = font->lfPitchAndFamily;
-    lstrcpynWtoA( font16.lfFaceName, font->lfFaceName, LF_FACESIZE );
+    FONT_LOGFONT32WToLOGFONT16(font,&font16);
     return CreateFontIndirect16( &font16 );
 }
 
@@ -1224,7 +1271,7 @@
 /*************************************************************************
  *				EnumFontFamilies	[GDI.330]
  */
-INT EnumFontFamilies(HDC16 hDC, LPCSTR lpszFamily, FONTENUMPROC16 lpEnumFunc, LPARAM lpData)
+INT16 EnumFontFamilies16(HDC16 hDC, LPCSTR lpszFamily, FONTENUMPROC16 lpEnumFunc, LPARAM lpData)
 {
   HLOCAL16     	hLog;
   HLOCAL16     	hMet;
@@ -1291,6 +1338,146 @@
 }
 
 /*************************************************************************
+ *				EnumFontFamiliesA	[GDI32.80]
+ */
+INT32 EnumFontFamilies32A(HDC32 hDC, LPCSTR lpszFamily, FONTENUMPROC32A lpEnumFunc, LPARAM lpData)
+{
+  HLOCAL16     	hLog;
+  HLOCAL16     	hMet;
+  HFONT32	hFont;
+  HFONT32	hOldFont;
+  LPENUMLOGFONT32A	lpEnumLogFont;
+  LPTEXTMETRIC32A	lptm;
+  LPSTR	       	lpOldName;
+  char	       	FaceName[LF_FACESIZE];
+  int	       	nRet = 0;
+  int	       	i;
+  
+  dprintf_font(stddeb,"EnumFontFamilies32A(%04x, %p, %08lx, %08lx)\n",
+	       hDC, lpszFamily, (DWORD)lpEnumFunc, lpData);
+  if (lpEnumFunc == 0) return 0;
+  hLog = GDI_HEAP_ALLOC( sizeof(ENUMLOGFONT32A) );
+  lpEnumLogFont = (LPENUMLOGFONT32A) GDI_HEAP_LIN_ADDR(hLog);
+  if (lpEnumLogFont == NULL) {
+    fprintf(stderr,"EnumFontFamilies // can't alloc LOGFONT struct !\n");
+    return 0;
+  }
+  hMet = GDI_HEAP_ALLOC( sizeof(TEXTMETRIC32A) );
+  lptm = (LPTEXTMETRIC32A) GDI_HEAP_LIN_ADDR(hMet);
+  if (lptm == NULL) {
+    GDI_HEAP_FREE(hLog);
+    fprintf(stderr,"EnumFontFamilies32A // can't alloc TEXTMETRIC struct !\n");
+    return 0;
+  }
+  lpOldName = NULL;
+  if (lpszFamily != NULL) {
+    strcpy(FaceName, lpszFamily);
+    AnsiUpper(FaceName);
+  }
+  if (lpLogFontList[0] == NULL) InitFontsList();
+  for(i = 0; lpLogFontList[i] != NULL; i++) {
+    if (lpszFamily == NULL) {
+      if (lpOldName != NULL) {
+	if (strcmp(lpOldName,lpLogFontList[i]->lfFaceName) == 0) continue;
+      }
+      lpOldName = lpLogFontList[i]->lfFaceName;
+    } else {
+      if (strcmp(FaceName, lpLogFontList[i]->lfFaceName) != 0) continue;
+    }
+    FONT_LOGFONT16ToLOGFONT32A(lpLogFontList[i],&(lpEnumLogFont->elfLogFont));
+    strcpy(lpEnumLogFont->elfFullName,"");
+    strcpy(lpEnumLogFont->elfStyle,"");
+    hFont = CreateFontIndirect32A((LPLOGFONT32A)lpEnumLogFont);
+    hOldFont = SelectObject32(hDC, hFont);
+    GetTextMetrics32A(hDC, lptm);
+    SelectObject32(hDC, hOldFont);
+    DeleteObject32(hFont);
+    dprintf_font(stddeb, "EnumFontFamilies32A // i=%d lpLogFont=%p lptm=%p\n", i, lpEnumLogFont, lptm);
+    
+    nRet = lpEnumFunc( GDI_HEAP_LIN_ADDR(hLog), GDI_HEAP_LIN_ADDR(hMet),
+                       0, lpData );
+    if (nRet == 0) {
+      dprintf_font(stddeb,"EnumFontFamilies32A // EnumEnd requested by application !\n");
+      break;
+    }
+  }
+  GDI_HEAP_FREE(hMet);
+  GDI_HEAP_FREE(hLog);
+  return nRet;
+}
+
+/*************************************************************************
+ *				EnumFontFamiliesW	[GDI32.83]
+ */
+INT32 EnumFontFamilies32W(HDC32 hDC, LPCWSTR lpszFamilyW, FONTENUMPROC32W lpEnumFunc, LPARAM lpData)
+{
+  HLOCAL16     	hLog;
+  HLOCAL16     	hMet;
+  HFONT32	hFont;
+  HFONT32	hOldFont;
+  LPENUMLOGFONT32W	lpEnumLogFont;
+  LPTEXTMETRIC32W	lptm;
+  LPSTR	       	lpOldName;
+  char	       	FaceName[LF_FACESIZE];
+  int	       	nRet = 0;
+  int	       	i;
+  LPCSTR	lpszFamily=lpszFamilyW?STRING32_DupUniToAnsi(lpszFamilyW):NULL;
+  
+  dprintf_font(stddeb,"EnumFontFamilies32W(%04x, %p, %08lx, %08lx)\n",
+	       hDC, lpszFamily, (DWORD)lpEnumFunc, lpData);
+  if (lpEnumFunc == 0) return 0;
+  hLog = GDI_HEAP_ALLOC( sizeof(ENUMLOGFONT32W) );
+  lpEnumLogFont = (LPENUMLOGFONT32W) GDI_HEAP_LIN_ADDR(hLog);
+  if (lpEnumLogFont == NULL) {
+    fprintf(stderr,"EnumFontFamilies32W // can't alloc LOGFONT struct !\n");
+    return 0;
+  }
+  hMet = GDI_HEAP_ALLOC( sizeof(TEXTMETRIC32W) );
+  lptm = (LPTEXTMETRIC32W) GDI_HEAP_LIN_ADDR(hMet);
+  if (lptm == NULL) {
+    GDI_HEAP_FREE(hLog);
+    fprintf(stderr,"EnumFontFamilies32W // can't alloc TEXTMETRIC struct !\n");
+    return 0;
+  }
+  lpOldName = NULL;
+  if (lpszFamily != NULL) {
+    strcpy(FaceName, lpszFamily);
+    AnsiUpper(FaceName);
+  }
+  if (lpLogFontList[0] == NULL) InitFontsList();
+  for(i = 0; lpLogFontList[i] != NULL; i++) {
+    if (lpszFamily == NULL) {
+      if (lpOldName != NULL) {
+	if (strcmp(lpOldName,lpLogFontList[i]->lfFaceName) == 0) continue;
+      }
+      lpOldName = lpLogFontList[i]->lfFaceName;
+    } else {
+      if (strcmp(FaceName, lpLogFontList[i]->lfFaceName) != 0) continue;
+    }
+    FONT_LOGFONT16ToLOGFONT32W(lpLogFontList[i],&(lpEnumLogFont->elfLogFont));
+    lstrcpynAtoW(lpEnumLogFont->elfFullName,"",1);
+    lstrcpynAtoW(lpEnumLogFont->elfStyle,"",1);
+    hFont = CreateFontIndirect32W((LPLOGFONT32W)lpEnumLogFont);
+    hOldFont = SelectObject32(hDC, hFont);
+    GetTextMetrics32W(hDC, lptm);
+    SelectObject32(hDC, hOldFont);
+    DeleteObject32(hFont);
+    dprintf_font(stddeb, "EnumFontFamilies32W // i=%d lpLogFont=%p lptm=%p\n", i, lpEnumLogFont, lptm);
+    
+    nRet = lpEnumFunc( GDI_HEAP_LIN_ADDR(hLog), GDI_HEAP_LIN_ADDR(hMet),
+                       0, lpData );
+    if (nRet == 0) {
+      dprintf_font(stddeb,"EnumFontFamilies32W // EnumEnd requested by application !\n");
+      break;
+    }
+  }
+  GDI_HEAP_FREE(hMet);
+  GDI_HEAP_FREE(hLog);
+  return nRet;
+}
+
+
+/*************************************************************************
  *				GetRasterizerCaps	[GDI.313]
  */
 
diff --git a/objects/metafile.c b/objects/metafile.c
index ad885d6..65e5484 100644
--- a/objects/metafile.c
+++ b/objects/metafile.c
@@ -522,9 +522,9 @@
 	break;
 
     case META_PATBLT:
-	PatBlt(hdc, *(mr->rdParam + 5), *(mr->rdParam + 4),
-	       *(mr->rdParam + 3), *(mr->rdParam + 2),
-	       MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
+	PatBlt16(hdc, *(mr->rdParam + 5), *(mr->rdParam + 4),
+                 *(mr->rdParam + 3), *(mr->rdParam + 2),
+                 MAKELONG(*(mr->rdParam), *(mr->rdParam + 1)));
 	break;
 
     case META_SAVEDC:
@@ -705,7 +705,7 @@
                                       mr->rdParam[14], /*BitsPixel*/
                                       (LPSTR)&mr->rdParam[15]);  /*bits*/
        SelectObject32(hdcSrc,hbitmap);
-       StretchBlt(hdc,mr->rdParam[9],mr->rdParam[8],
+       StretchBlt32(hdc,mr->rdParam[9],mr->rdParam[8],
                     mr->rdParam[7],mr->rdParam[6],
 		    hdcSrc,mr->rdParam[5],mr->rdParam[4],
 		    mr->rdParam[3],mr->rdParam[2],
@@ -721,11 +721,10 @@
                             mr->rdParam[10]/*Planes*/,mr->rdParam[11]/*BitsPixel*/,
                             (LPSTR)&mr->rdParam[12]/*bits*/);
        SelectObject32(hdcSrc,hbitmap);
-       BitBlt(hdc,mr->rdParam[6],mr->rdParam[5],
-                    mr->rdParam[4],mr->rdParam[3],
-		    hdcSrc,
-		    mr->rdParam[2],mr->rdParam[1],
-		    MAKELONG(0,mr->rdParam[0]));
+       BitBlt32(hdc,mr->rdParam[6],mr->rdParam[5],
+                mr->rdParam[4],mr->rdParam[3],
+                hdcSrc, mr->rdParam[2],mr->rdParam[1],
+                MAKELONG(0,mr->rdParam[0]));
        DeleteDC(hdcSrc);		    
       }
       break;
@@ -1157,16 +1156,14 @@
  *         MF_BitBlt
  */
 BOOL32 MF_BitBlt(DC *dcDest, short xDest, short yDest, short width,
-                 short height, HDC16 hdcSrc, short xSrc, short ySrc, DWORD rop)
+                 short height, DC *dcSrc, short xSrc, short ySrc, DWORD rop)
 {
     BOOL32 ret;
     DWORD len;
     HGLOBAL16 hmr;
     METARECORD *mr;
-    DC *dcSrc;
     BITMAP16  BM;
 
-    if (!(dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC ))) return 0;
     GetObject16(dcSrc->w.hBitmap, sizeof(BITMAP16), &BM);
     len = sizeof(METARECORD) + 12 * sizeof(INT16) + BM.bmWidthBytes * BM.bmHeight;
     if (!(hmr = GlobalAlloc16(GMEM_MOVEABLE, len)))
@@ -1207,20 +1204,18 @@
 #define STRETCH_VIA_DIB
 #undef  STRETCH_VIA_DIB
 BOOL32 MF_StretchBlt(DC *dcDest, short xDest, short yDest, short widthDest,
-                     short heightDest, HDC16 hdcSrc, short xSrc, short ySrc, 
+                     short heightDest, DC *dcSrc, short xSrc, short ySrc, 
                      short widthSrc, short heightSrc, DWORD rop)
 {
     BOOL32 ret;
     DWORD len;
     HGLOBAL16 hmr;
     METARECORD *mr;
-    DC *dcSrc;
     BITMAP16  BM;
 #ifdef STRETCH_VIA_DIB    
     LPBITMAPINFOHEADER lpBMI;
     WORD nBPP;
 #endif  
-    if (!(dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC ))) return 0;
     GetObject16(dcSrc->w.hBitmap, sizeof(BITMAP16), &BM);
 #ifdef STRETCH_VIA_DIB
     nBPP = BM.bmPlanes * BM.bmBitsPixel;
@@ -1240,8 +1235,8 @@
     lpBMI->biClrUsed   = nBPP != 24 ? 1 << nBPP : 0;
     lpBMI->biSizeImage = ((lpBMI->biWidth * nBPP + 31) / 32) * 4 * lpBMI->biHeight;
     lpBMI->biCompression = BI_RGB;
-    lpBMI->biXPelsPerMeter = MulDiv32(GetDeviceCaps(hdcSrc,LOGPIXELSX),3937,100);
-    lpBMI->biYPelsPerMeter = MulDiv32(GetDeviceCaps(hdcSrc,LOGPIXELSY),3937,100);
+    lpBMI->biXPelsPerMeter = MulDiv32(GetDeviceCaps(dcSrc->hSelf,LOGPIXELSX),3937,100);
+    lpBMI->biYPelsPerMeter = MulDiv32(GetDeviceCaps(dcSrc->hSelf,LOGPIXELSY),3937,100);
     lpBMI->biClrImportant  = 0;                          /* 1 meter  = 39.37 inch */
 
     dprintf_metafile(stddeb,"MF_StretchBltViaDIB->len = %ld  rop=%lx  PixYPM=%ld Caps=%d\n",
diff --git a/objects/palette.c b/objects/palette.c
index 39a1ae7..7a67571 100644
--- a/objects/palette.c
+++ b/objects/palette.c
@@ -9,8 +9,10 @@
 #include <string.h>
 #include <X11/Xlib.h>
 
+#include "gdi.h"
 #include "color.h"
 #include "palette.h"
+#include "xmalloc.h"
 #include "stddebug.h"
 /* #define DEBUG_PALETTE */
 #include "debug.h"
@@ -120,12 +122,38 @@
  */
 BOOL ResizePalette(HPALETTE16 hPal, UINT cEntries)
 {
+    PALETTEOBJ * palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
+    UINT	 cPrevEnt, prevVer;
+    int		 prevsize, size = sizeof(LOGPALETTE) + (cEntries - 1) * sizeof(PALETTEENTRY);
+    int*	 mapping = NULL;
 
-    /* should simply realloc memory and zero out
-     * added entries, if any */
+    dprintf_palette(stddeb,"ResizePalette: hpal = %04x, prev = %i, new = %i\n",
+		    hPal, (palPtr)? -1: palPtr->logpalette.palNumEntries, cEntries );
+    if( !palPtr ) return FALSE;
+    cPrevEnt = palPtr->logpalette.palNumEntries;
+    prevVer = palPtr->logpalette.palVersion;
+    prevsize = sizeof(LOGPALETTE) + (cPrevEnt - 1) * sizeof(PALETTEENTRY) +
+	      				sizeof(int*) + sizeof(GDIOBJHDR);
+    size += sizeof(int*) + sizeof(GDIOBJHDR);
+    mapping = palPtr->mapping;
 
-    fprintf(stdnimp,"ResizePalette: empty stub! \n");
-    return FALSE;
+    GDI_HEAP_REALLOC( hPal, size );
+    palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC );
+    if( !palPtr ) return FALSE;
+
+    if( mapping )
+        palPtr->mapping = (int*) xrealloc( mapping, cEntries * sizeof(int) );
+    if( cEntries > cPrevEnt ) 
+    {
+	if( mapping )
+	    memset(palPtr->mapping + cPrevEnt, 0, (cEntries - cPrevEnt)*sizeof(int));
+	memset( (BYTE*)palPtr + prevsize, 0, size - prevsize );
+        PALETTE_ValidateFlags((PALETTEENTRY*)((BYTE*)palPtr + prevsize), 
+						     cEntries - cPrevEnt );
+    }
+    palPtr->logpalette.palNumEntries = cEntries;
+    palPtr->logpalette.palVersion = prevVer;
+    return TRUE;
 }
 
 /***********************************************************************
diff --git a/objects/region.c b/objects/region.c
index 4404062..40dae541 100644
--- a/objects/region.c
+++ b/objects/region.c
@@ -487,7 +487,7 @@
  *
  * Add rectangle to region
  */
-BOOL32 REGION_UnionRectWithRgn( HRGN32 hRgn, LPRECT16 rc )
+BOOL32 REGION_UnionRectWithRgn( HRGN32 hRgn, const RECT32 *rc )
 {
   RGNOBJ 	*rgnObj = (RGNOBJ*) GDI_GetObjPtr( hRgn, REGION_MAGIC );
   XRectangle     rect = { rc->left, rc->top, rc->right - rc->left, rc->bottom - rc->top };
diff --git a/objects/text.c b/objects/text.c
index 1862afe..782fe70 100644
--- a/objects/text.c
+++ b/objects/text.c
@@ -447,17 +447,9 @@
 
     if (flags & ETO_CLIPPED)
     {
-       if (dc->w.flags & DC_MEMORY)
-       {
-	  hRgnClip = dc->w.hClipRgn;
-	  CLIPPING_IntersectClipRect(dc, rect.left, rect.top, rect.right, rect.bottom,
-					 CLIP_INTERSECT | CLIP_KEEPRGN);
-       }
-       else
-       { 
-          SaveVisRgn( hdc );
-          IntersectVisRect( hdc, rect.left, rect.top, rect.right, rect.bottom );
-       }
+        hRgnClip = dc->w.hClipRgn;
+        CLIPPING_IntersectClipRect( dc, rect.left, rect.top, rect.right,
+                                    rect.bottom, CLIP_INTERSECT|CLIP_KEEPRGN );
     }
 
       /* Draw the text background if necessary */
@@ -565,11 +557,7 @@
 		   dc->w.DCOrgX + x + info.width, dc->w.DCOrgY + y - lineAscent );
     }
 
-    if (flags & ETO_CLIPPED) 
-    {
-	if (dc->w.flags & DC_MEMORY) SelectClipRgn16( hdc, hRgnClip );
-	else RestoreVisRgn( hdc );
-    }
+    if (flags & ETO_CLIPPED) SelectClipRgn32( hdc, hRgnClip );
     return TRUE;
 }
 
diff --git a/programs/progman/Makefile.in b/programs/progman/Makefile.in
index ddf06ce..ea2e954 100644
--- a/programs/progman/Makefile.in
+++ b/programs/progman/Makefile.in
@@ -6,6 +6,7 @@
 PROGRAMS  = progman
 ALL_LIBS  = $(WINELIB) $(X_LIBS) $(XPM_LIB) $(XLIB) $(LDLIBS)
 DEFS      = -I$(SRCDIR)
+RCFLAGS   = -w32
 
 LANGUAGES   = En De Fr Fi
 LICENSELANG = En
diff --git a/programs/winhelp/Makefile.in b/programs/winhelp/Makefile.in
index cb6a691..d70b716 100644
--- a/programs/winhelp/Makefile.in
+++ b/programs/winhelp/Makefile.in
@@ -5,6 +5,7 @@
 MODULE    = none
 PROGRAMS  = winhelp hlp2sgml
 ALL_LIBS  = $(WINELIB) $(X_LIBS) $(XPM_LIB) $(XLIB) $(LDLIBS)
+RCFLAGS   = -w32
 
 LANGUAGES   = En De Fr Fi
 
diff --git a/rc/winerc.c b/rc/winerc.c
index 43a27f3..63a9f4e 100644
--- a/rc/winerc.c
+++ b/rc/winerc.c
@@ -21,11 +21,12 @@
 	"   -d            Output debugging information\n"
 	"   -p prefix     Give a prefix for the generated names\n"
 	"   -v            Show each resource as it is processed\n"
-	"   -o file       Output to file.c and file.h\n";
-
+	"   -o file       Output to file.c and file.h\n"
+	"   -w 16|32      Select win16 or win32 output\n";
 
 /*might be overwritten by command line*/
 char *prefix="_Resource";
+int win32=1;
 int verbose,constant;
 gen_res* g_start;
 FILE *header,*code;
@@ -55,7 +56,7 @@
 	char* tmpc;
 	int optc,lose,ret,binary;
 	lose=binary=0;
-	while((optc=getopt(argc,argv,"bcdp:vo:"))!=EOF)
+	while((optc=getopt(argc,argv,"bcdp:vo:w:"))!=EOF)
 		switch(optc)
 		{
 			/* bison will print state transitions on stderr */
@@ -76,6 +77,10 @@
 					 setbuf(stderr,0);
 					break;
 			case 'o':set_out_file(optarg);break;
+			case 'w':if(!strcmp(optarg,"16"))win32=0;
+				 else if(!strcmp(optarg,"32"))win32=1;
+				 else lose++;
+				 break;
 			default: lose++;break;
 		}
 	if(lose)return fprintf(stderr,usage),1;
@@ -195,6 +200,35 @@
 	return res;
 }
 
+/* insert string into res, starting at start */
+gen_res* insert_string(gen_res* res,unsigned char* string,int start,int terminating0)
+{
+	unsigned char* p;
+	int lengthA = strlen(string) + (terminating0 ? 1 : 0);
+	int length = (win32 ? 2 : 1) * lengthA; 
+	while(res->size+length>res->space)res=grow(res);
+	save_memcpy(res->res+start+length,res->res+start,res->size-start);
+	p=res->res+start;
+	while(lengthA--)
+		if (win32)
+		{
+			put_WORD(p, *string++);
+			p+=2;
+		}
+		else
+			*p++=*string++;
+	res->size+=length;
+	return res;
+}
+
+/* insert string at offset 0, increase num_entries */
+gen_res* insert_string_at_beginning(gen_res* res,char* entry,int terminating0)
+{
+	res=insert_string(res,entry,0,terminating0);
+	res->num_entries++;
+	return res;
+}
+
 /*delete len bytes from res, starting at start*/
 gen_res* delete_bytes(gen_res* res,int start,int len)
 {
@@ -253,7 +287,7 @@
 /* create a new dialog header, set all items to 0 */
 gen_res* new_dialog()
 {	gen_res* ret=new_res();
-	ret->size=16; /*all strings "\0", no font*/
+	ret->size=win32?24:16; /*all strings "\0", no font*/
 	return ret;
 }
 
@@ -266,18 +300,18 @@
 	return attr;
 }
 
-/* menu name is at offset 13 */
+/* menu name is at offset 13 (win32: 18) */
 int dialog_get_menu(gen_res* attr)
 {
-	return 13;
+	return win32?18:13;
 }
 
 /* the class is after the menu name */
 int dialog_get_class(gen_res* attr)
 {
 	int offs=dialog_get_menu(attr);
-	while(attr->res[offs])offs++;
-	offs++;
+	while(attr->res[offs]||(win32&&attr->res[offs+1]))offs+=win32?2:1;
+	offs+=win32?2:1;
 	return offs;
 }
 
@@ -285,8 +319,8 @@
 int dialog_get_caption(gen_res* attr)
 {
 	int offs=dialog_get_class(attr);
-	while(attr->res[offs])offs++;
-	offs++;
+	while(attr->res[offs]||(win32&&attr->res[offs+1]))offs+=win32?2:1;
+	offs+=win32?2:1;
 	return offs;
 }
 
@@ -294,8 +328,8 @@
 int dialog_get_fontsize(gen_res* attr)
 {
 	int offs=dialog_get_caption(attr);
-	while(attr->res[offs])offs++;
-	offs++;
+	while(attr->res[offs]||(win32&&attr->res[offs+1]))offs+=win32?2:1;
+	offs+=win32?2:1;
 	return offs;
 }
 
@@ -304,7 +338,7 @@
 gen_res* dialog_caption(char* cap, gen_res*attr)
 {
 	/* we don't need the terminating 0 as it's already there */
-	return insert_bytes(attr,cap,dialog_get_caption(attr),strlen(cap));
+	return insert_string(attr,cap,dialog_get_caption(attr),0);
 }
 
 
@@ -318,31 +352,47 @@
 	attr=insert_bytes(attr,c_size,offs,2);
 	offs+=2;
 	/* as there is no font name by default, copy the '\0' */
-	return insert_bytes(attr,font,offs,strlen(font)+1);
+	return insert_string(attr,font,offs,1);
 }
 
 gen_res* dialog_class(char* cap, gen_res*attr)
 {
-	return insert_bytes(attr,cap,dialog_get_class(attr),strlen(cap));
+	return insert_string(attr,cap,dialog_get_class(attr),0);
 }
 
 gen_res* dialog_menu(char* cap, gen_res*attr)
 {
-	return insert_bytes(attr,cap,dialog_get_menu(attr),strlen(cap));
+	return insert_string(attr,cap,dialog_get_menu(attr),0);
 }
 
 /* set the dialogs id, position, extent, and style */
 gen_res* create_control_desc(int id,int x,int y,int cx, int cy,rc_style *style)
 {	gen_res* ret=new_res();
 	int s=WS_VISIBLE|WS_CHILD; /*defaults styles for any control*/
-	put_WORD(ret->res+0,x);
-	put_WORD(ret->res+2,y);
-	put_WORD(ret->res+4,cx);
-	put_WORD(ret->res+6,cy);
-	put_WORD(ret->res+8,id);
-	if(style)s=(s|style->or)&style->and;
-	put_DWORD(ret->res+10,s);
-	ret->size=17; /*empty strings, unused byte*/
+	if(win32)
+	{
+		if(style)s=(s|style->or)&style->and;
+		put_DWORD(ret->res+0,s);
+		/* FIXME */
+		/* put_WORD(ret->res+4, exStyle); */
+		put_WORD(ret->res+8,x);
+		put_WORD(ret->res+10,y);
+		put_WORD(ret->res+12,cx);
+		put_WORD(ret->res+14,cy);
+		put_WORD(ret->res+16,id);
+		ret->size=24; /*empty strings, unused byte*/
+	}
+	else
+	{
+		put_WORD(ret->res+0,x);
+		put_WORD(ret->res+2,y);
+		put_WORD(ret->res+4,cx);
+		put_WORD(ret->res+6,cy);
+		put_WORD(ret->res+8,id);
+		if(style)s=(s|style->or)&style->and;
+		put_DWORD(ret->res+10,s);
+		ret->size=17; /*empty strings, unused byte*/
+	}
 	return ret;
 }
 
@@ -350,45 +400,99 @@
 gen_res* label_control_desc(char* label,gen_res* cd)
 {
 	int offs;
-	if(cd->res[14]&0x80)offs=15; /* one-character class */
-	else {
-		for(offs=14;cd->res[offs];offs++);
-		offs++;
+	if(win32) {
+		if(get_WORD(cd->res+18)==0xffff)offs=20; /* one-character class */
+		else {
+			for(offs=18;get_WORD(cd->res+offs);offs+=2);
+			offs+=2;
+		}
 	}
-	return insert_bytes(cd,label,offs,strlen(label));
+	else {
+		if(cd->res[14]&0x80)offs=15; /* one-character class */
+		else {
+			for(offs=14;cd->res[offs];offs++);
+			offs++;
+		}
+	}
+	return insert_string(cd,label,offs,0);
 }
 
 /* a CONTROL was specified */
 gen_res* create_generic_control(char* label,int id,char* class,
 	rc_style*style,int x,int y,int cx,int cy)
-{	char cl;
-	gen_res* ret=new_res();
-	put_WORD(ret->res+0,x);
-    put_WORD(ret->res+2,y);
-    put_WORD(ret->res+4,cx);
-    put_WORD(ret->res+6,cy);
-    put_WORD(ret->res+8,id);
-	put_DWORD(ret->res+10,style->or);
-	ret->size=17;
-	ret=insert_bytes(ret,label,15,strlen(label));
-	/* is it a predefined class? */
-	cl=0;
-	if(!strcmp(class,"BUTTON"))cl=CT_BUTTON;
-	if(!strcmp(class,"EDIT"))cl=CT_EDIT;
-	if(!strcmp(class,"STATIC"))cl=CT_STATIC;
-	if(!strcmp(class,"LISTBOX"))cl=CT_LISTBOX;
-	if(!strcmp(class,"SCROLLBAR"))cl=CT_SCROLLBAR;
-	if(!strcmp(class,"COMBOBOX"))cl=CT_COMBOBOX;
-	if(cl)ret->res[14]=cl;
-	else ret=insert_bytes(ret,class,14,strlen(class));
+{	gen_res* ret=new_res();
+	if(win32)
+	{
+		WORD cl;
+		put_DWORD(ret->res+0,style->or);
+		/* FIXME */
+		/* put_DWORD(ret->res+4,exstyle->or); */
+		put_WORD(ret->res+8,x);
+		put_WORD(ret->res+10,y);
+		put_WORD(ret->res+12,cx);
+		put_WORD(ret->res+14,cy);
+		put_WORD(ret->res+16,id);
+		ret->size=win32?24:17;
+		ret=insert_string(ret,label,20,0);
+		/* is it a predefined class? */
+		cl=0;
+		if(!strcmp(class,"BUTTON"))cl=CT_BUTTON;
+		if(!strcmp(class,"EDIT"))cl=CT_EDIT;
+		if(!strcmp(class,"STATIC"))cl=CT_STATIC;
+		if(!strcmp(class,"LISTBOX"))cl=CT_LISTBOX;
+		if(!strcmp(class,"SCROLLBAR"))cl=CT_SCROLLBAR;
+		if(!strcmp(class,"COMBOBOX"))cl=CT_COMBOBOX;
+		if(cl) {
+			char ffff[2]={0xff, 0xff};
+			ret=insert_bytes(ret,ffff,18,2);
+			put_WORD(ret->res+20,cl);
+		}
+		else ret=insert_string(ret,class,18,0);
+	}
+	else
+	{
+		char cl;
+		put_WORD(ret->res+0,x);
+		put_WORD(ret->res+2,y);
+		put_WORD(ret->res+4,cx);
+		put_WORD(ret->res+6,cy);
+		put_WORD(ret->res+8,id);
+		put_DWORD(ret->res+10,style->or);
+		ret->size=17;
+		ret=insert_string(ret,label,15,0);
+		/* is it a predefined class? */
+		cl=0;
+		if(!strcmp(class,"BUTTON"))cl=CT_BUTTON;
+		if(!strcmp(class,"EDIT"))cl=CT_EDIT;
+		if(!strcmp(class,"STATIC"))cl=CT_STATIC;
+		if(!strcmp(class,"LISTBOX"))cl=CT_LISTBOX;
+		if(!strcmp(class,"SCROLLBAR"))cl=CT_SCROLLBAR;
+		if(!strcmp(class,"COMBOBOX"))cl=CT_COMBOBOX;
+		if(cl)ret->res[14]=cl;
+		else ret=insert_string(ret,class,14,0);
+	}
 	return ret;
 }
 
 /* insert cd into rest, set the type, add flags */
 gen_res* add_control(int type,int flags,gen_res*cd,gen_res* rest)
 {
-	put_DWORD(cd->res+10,get_DWORD(cd->res+10)|flags);
-	cd->res[14]=type;
+	char zeros[4]={0,0,0,0};
+	if(win32)
+	{
+		char ffff[2]={0xff, 0xff};
+		put_DWORD(cd->res+0,get_DWORD(cd->res+0)|flags);
+		cd=insert_bytes(cd,ffff,18,2);
+		put_WORD(cd->res+20,type);
+	}
+	else
+	{
+		put_DWORD(cd->res+10,get_DWORD(cd->res+10)|flags);
+		cd->res[14]=type;
+	}
+	/* WIN32: First control is on dword boundary */
+	if(win32 && cd->size%4)
+		cd=insert_bytes(cd,zeros,cd->size,4-cd->size%4);
 	return insert_at_beginning(rest,cd->res,cd->size);
 }
 
@@ -412,12 +516,28 @@
    Set position and extent */
 gen_res* make_dialog(gen_res* header,int x,int y,int cx,int cy,gen_res* ctls)
 {
-	header->res[4]=ctls->num_entries;
-	header->type=dlg;
-	put_WORD(header->res+5,x);
-	put_WORD(header->res+7,y);
-	put_WORD(header->res+9,cx);
-	put_WORD(header->res+11,cy);
+	char zeros[4]={0,0,0,0};
+	if(win32)
+	{
+		put_WORD(header->res+8, ctls->num_entries);
+		header->type=dlg;
+		put_WORD(header->res+10,x);
+		put_WORD(header->res+12,y);
+		put_WORD(header->res+14,cx);
+		put_WORD(header->res+16,cy);
+	}
+	else
+	{
+		header->res[4]=ctls->num_entries;
+		header->type=dlg;
+		put_WORD(header->res+5,x);
+		put_WORD(header->res+7,y);
+		put_WORD(header->res+9,cx);
+		put_WORD(header->res+11,cy);
+	}
+	/* WIN32: First control is on dword boundary */
+	if(win32 && header->size%4)
+		header=insert_bytes(header,zeros,header->size,4-header->size%4);
 	return insert_bytes(header,ctls->res,header->size,ctls->size);
 }
 
@@ -473,7 +593,7 @@
 	if(res->num_entries==0)flags|=MF_END;
 	put_WORD(item,flags);
 	put_WORD(item+2,id);
-	res=insert_at_beginning(res,name,strlen(name)+1);
+	res=insert_string_at_beginning(res,name,1);
 	res=insert_bytes(res,item,0,4);
 	return res;
 }
@@ -486,7 +606,7 @@
 	if(res->num_entries==0)flags|=MF_END;
 	put_WORD(c_flags,flags);
 	res=insert_at_beginning(res,body->res,body->size);
-	res=insert_bytes(res,name,0,strlen(name)+1);
+	res=insert_string(res,name,0,1);
 	res=insert_bytes(res,c_flags,0,2);
 	return res;
 }
@@ -543,27 +663,45 @@
   int size,i;
   gen_res* res;
   unsigned char* p;
-  char* q;
+  unsigned char* q;
 
   if(!string_table) return t;
   for(ste=string_table; ste; ste=ste->next)
   {
     for(size=0,i=0; i<16; i++)
-      size += ste->strings[i] ? strlen(ste->strings[i])+1 : 1;
+      size += (win32 ? 2 : 1) * (ste->strings[i] ? strlen(ste->strings[i])+1 : 1);
     res=new_res();
     while(res->space<size)res=grow(res);
     res->type=str;
     res->n.i_name=ste->group;
     res->n_type=0;
     res->size=size;
-    for(p=res->res,i=0; i<16; i++)
-      if((q=ste->strings[i])==NULL)
-	*p++ = 0;
-      else
-      {
-	*p++ = strlen(q);
-	while(*q) *p++ = *q++;
-      }
+    if (win32)
+      for(p=res->res,i=0; i<16; i++)
+        if((q=ste->strings[i])==NULL)
+        {
+	  put_WORD(p, 0);
+	  p+=2;
+	}
+	else
+	{
+	  put_WORD(p, strlen(q));
+	  p+=2;
+	  while(*q)
+	  {
+	    put_WORD(p, *q++);
+	    p+=2;
+	  }
+	}
+    else
+      for(p=res->res,i=0; i<16; i++)
+	if((q=ste->strings[i])==NULL)
+	  *p++ = 0;
+	else
+	{
+	  *p++ = strlen(q);
+	  while(*q) *p++ = *q++;
+	}
     t=add_resource(res,t);
   }
   return t;
@@ -628,8 +766,9 @@
     for(it=top;it;it=it->next)
     {
         int i;
-        fprintf( code, "static %sunsigned char %s__bytes[] = {\n",
-                 ISCONSTANT, get_resource_name(it) );
+        fprintf( code, "static %sunsigned char %s__bytes[]%s = {\n",
+                 ISCONSTANT, get_resource_name(it),
+		 win32?"\n__attribute__ ((aligned (4)))":"");
         for (i=0;i<it->size-1;i++)
         {
             fprintf(code,"0x%02x, ",it->res[i]);
@@ -638,6 +777,25 @@
         fprintf(code,"0x%02x };\n\n",it->res[i]);
     }
 
+    /* Print the resources names */
+
+    if (win32)
+        for(it=top;it;it=it->next)
+        {
+            int i;
+	    char s_buffer[20], *s_name=s_buffer;
+	    if(it->n_type) s_name=it->n.s_name;
+	    else sprintf(s_name,"@%d",it->n.i_name);
+	    fprintf( code, "static %sunsigned char %s__name[] = {\n",
+		     ISCONSTANT, get_resource_name(it) );
+	    for (i=0;*s_name;i++,s_name++)
+	      {
+		fprintf(code,"0x%02x, 0x00, ",*s_name);
+		if ((i&3)==3)fputc('\n',code);
+	      }
+	    fprintf(code,"0x00, 0x00};\n\n");
+	}
+
     /* Print the resources */
     for (it=top;it;it=it->next)
     {
@@ -655,14 +813,28 @@
         case str:type=(int)RT_STRING;break;
         default:fprintf(stderr,"Unknown restype\n");type=-1;break;
         }
-        if(it->n_type)
-            fprintf(code,"%sstruct resource %s = {0,%d,\"%s\",%s__bytes,%d};\n",
-                    ISCONSTANT, get_resource_name(it), type, it->n.s_name,
-                    get_resource_name(it), it->size );
-        else
-            fprintf(code,"%sstruct resource %s = {%d,%d,\"@%d\",%s__bytes,%d};\n",
-                    ISCONSTANT, get_resource_name(it), it->n.i_name, type,
-                    it->n.i_name, get_resource_name(it), it->size );
+	if(win32)
+	{
+            if(it->n_type)
+                fprintf(code,"%sstruct resource %s = {0,%d,%s__name,%s__bytes,%d};\n",
+			ISCONSTANT, get_resource_name(it), type, get_resource_name(it),
+			get_resource_name(it), it->size );
+	    else
+	        fprintf(code,"%sstruct resource %s = {%d,%d,%s__name,%s__bytes,%d};\n",
+			ISCONSTANT, get_resource_name(it), it->n.i_name, type,
+			get_resource_name(it), get_resource_name(it), it->size );
+	}
+	else
+	{
+            if(it->n_type)
+                fprintf(code,"%sstruct resource %s = {0,%d,\"%s\",%s__bytes,%d};\n",
+			ISCONSTANT, get_resource_name(it), type, it->n.s_name,
+			get_resource_name(it), it->size );
+	    else
+	        fprintf(code,"%sstruct resource %s = {%d,%d,\"@%d\",%s__bytes,%d};\n",
+			ISCONSTANT, get_resource_name(it), it->n.i_name, type,
+			it->n.i_name, get_resource_name(it), it->size );
+	}
     }
 
     /* Print the resource table (NULL terminated) */
diff --git a/resources/Makefile.in b/resources/Makefile.in
index e24d54f..f4f1e5c 100644
--- a/resources/Makefile.in
+++ b/resources/Makefile.in
@@ -4,6 +4,7 @@
 SRCDIR    = @srcdir@
 VPATH     = @srcdir@
 MODULE    = resources
+RCFLAGS   = -w16
 
 SYSRES_SRCS = \
 	sysres_Cz.c \
diff --git a/win32/code_page.c b/win32/code_page.c
index 731dd45..2d60fc4 100644
--- a/win32/code_page.c
+++ b/win32/code_page.c
@@ -5,11 +5,13 @@
  */
 
 #include <stdio.h>
+#include <malloc.h>
 #include "windows.h"
 #include "winerror.h"
 #include "winnls.h"
 #include "stddebug.h"
 #include "debug.h"
+#include "string32.h"
 
 
 /***********************************************************************
@@ -84,4 +86,30 @@
 	return count;
 }
 
-		
+/***********************************************************************
+ *              EnumSystemCodePages32A                (KERNEL32.92)
+ */
+BOOL32
+EnumSystemCodePages32A(CODEPAGE_ENUMPROC32A lpfnCodePageEnum,DWORD flags) {
+	dprintf_win32(stddeb,"EnumSystemCodePages32A(%p,%08lx)\n",
+		lpfnCodePageEnum,flags
+	);
+	lpfnCodePageEnum("437");
+	return TRUE;
+}
+
+/***********************************************************************
+ *              EnumSystemCodePages32W                (KERNEL32.93)
+ */
+BOOL32
+EnumSystemCodePages32W(CODEPAGE_ENUMPROC32W lpfnCodePageEnum,DWORD flags) {
+	WCHAR	*cp;
+	dprintf_win32(stddeb,"EnumSystemCodePages32W(%p,%08lx)\n",
+		lpfnCodePageEnum,flags
+	);
+
+	cp=STRING32_DupAnsiToUni("437");
+	lpfnCodePageEnum(cp);
+	free(cp);
+	return TRUE;
+}
diff --git a/win32/file.c b/win32/file.c
index 150322b..925de51 100644
--- a/win32/file.c
+++ b/win32/file.c
@@ -26,7 +26,6 @@
 #include "debug.h"
 
 
-static void UnixTimeToFileTime(time_t unix_time, FILETIME *filetime);
 static int TranslateCreationFlags(DWORD create_flags);
 static int TranslateAccessFlags(DWORD access_flags);
 int TranslateProtectionFlags(DWORD);
@@ -54,6 +53,9 @@
     HFILE hfile;
     FILEMAP_OBJECT *filemap_obj;
 
+    dprintf_win32(stddeb,"CreateFileMapping32A(%08x,%p,%ld,%ld,%ld,%s)\n",
+    	h,ats,pot,sh,hlow,lpName
+    );
     if (sh) {
         SetLastError(ErrnoToLastError(errno));
         return INVALID_HANDLE_VALUE;
@@ -94,6 +96,16 @@
 
 
 /***********************************************************************
+ *           MapViewOfFile                  (KERNEL32.385)
+ *
+ */
+LPVOID MapViewOfFile(HANDLE32 handle, DWORD access, DWORD offhi,
+                      DWORD offlo, DWORD size)
+{
+    return MapViewOfFileEx(handle,access,offhi,offlo,size,0);
+}
+
+/***********************************************************************
  *           MapViewOfFileEx                  (KERNEL32.386)
  *
  */
@@ -138,9 +150,9 @@
     /* Translate the file times.  Use the last modification time
      * for both the creation time and write time.
      */
-    UnixTimeToFileTime(file_stat.st_mtime, &(lpfi->ftCreationTime));
-    UnixTimeToFileTime(file_stat.st_mtime, &(lpfi->ftLastWriteTime));
-    UnixTimeToFileTime(file_stat.st_atime, &(lpfi->ftLastAccessTime));
+    DOSFS_UnixTimeToFileTime(file_stat.st_mtime, &(lpfi->ftCreationTime));
+    DOSFS_UnixTimeToFileTime(file_stat.st_mtime, &(lpfi->ftLastWriteTime));
+    DOSFS_UnixTimeToFileTime(file_stat.st_atime, &(lpfi->ftLastAccessTime));
 
     lpfi->nFileSizeLow = file_stat.st_size;
     lpfi->nNumberOfLinks = file_stat.st_nlink;
@@ -155,19 +167,18 @@
     return 1;
 }
 
-static void UnixTimeToFileTime(time_t unix_time, FILETIME *filetime)
-{
-    /* This isn't anywhere close to being correct, but should
-     * work for now.
-     */
-    filetime->dwLowDateTime  = (unix_time & 0x0000FFFF) << 16;
-    filetime->dwHighDateTime = (unix_time & 0xFFFF0000) >> 16;
-}
+/***********************************************************************
+ *           GetFileSize             (KERNEL32.220)
+ */
+DWORD GetFileSize(HFILE hf,LPDWORD filesizehigh) {
+    BY_HANDLE_FILE_INFORMATION	fi;
+	DWORD	res = GetFileInformationByHandle(hf,&fi);
 
-time_t FileTimeToUnixTime(FILETIME *filetime)
-{
-    /* reverse of UnixTimeToFileTime */
-    return (filetime->dwLowDateTime>>16)+(filetime->dwHighDateTime<<16);
+	if (!res) 
+		return 0;	/* FIXME: correct ? */
+	if (filesizehigh) 
+		*filesizehigh = fi.nFileSizeHigh;
+	return fi.nFileSizeLow;
 }
 
 /***********************************************************************
diff --git a/win32/findfile.c b/win32/findfile.c
index 8f9bf52..50bb75d 100644
--- a/win32/findfile.c
+++ b/win32/findfile.c
@@ -188,6 +188,8 @@
 {
     FindFileContext32 *context;
 
+	if (handle==(INVALID_HANDLE_VALUE))
+		return TRUE;
     context = (FindFileContext32 *) handle;
     if (context->dir)
 	closedir(context->dir);
diff --git a/win32/init.c b/win32/init.c
index 5fa1b3a..8585a93 100644
--- a/win32/init.c
+++ b/win32/init.c
@@ -55,15 +55,6 @@
 }
 
 /***********************************************************************
- *              GetModuleFileNameA      (KERNEL32.235)
- */
-DWORD GetModuleFileNameA(HMODULE32 hModule, LPSTR lpFilename, DWORD nSize)
-{
-    strcpy(lpFilename, "c:\\dummy");
-    return 8;
-}
-
-/***********************************************************************
  *              GetModuleHandle         (KERNEL32.237)
  */
 HMODULE32 WIN32_GetModuleHandle(char *module)
@@ -99,6 +90,26 @@
     lpStartupInfo->hStdError  = (HANDLE32)2;
 }
 
+/***********************************************************************
+ *              GetStartupInfoA         (KERNEL32.284)
+ * FIXME: perhaps supply better values.
+ */
+VOID
+GetSystemInfo(LPSYSTEM_INFO si) {
+    si->dwOemId		= 0x12345678;
+    si->dwPageSize	= 4096; /* 4K */
+    si->lpMinimumApplicationAddress = 0x40000000;
+    si->lpMaximumApplicationAddress = 0x80000000;
+    si->dwActiveProcessorMask       = 1;
+    si->dwNumberOfProcessors        = 1;
+#ifdef WINELIB
+    si->dwProcessorType             = 3;
+#else
+    si->dwProcessorType             = runtime_cpu();
+#endif
+    si->dwAllocationGranularity     = 8; /* hmm? */
+}
+
 /* Initialize whatever internal data structures we need.
  *
  * Returns 1 on success, 0 on failure.
diff --git a/win32/thread.c b/win32/thread.c
index 1495f7c..37e3c54 100644
--- a/win32/thread.c
+++ b/win32/thread.c
@@ -67,8 +67,11 @@
 	return;
 }
 
-void
-ReinitializeCriticalSection(CRITICAL_SECTION *lpCrit) {
+void ReinitializeCriticalSection(CRITICAL_SECTION *lpCrit) {
+	/* hmm */
+}
+
+void MakeCriticalSectionGlobal(CRITICAL_SECTION *lpCrit) {
 	/* hmm */
 }
 
diff --git a/windows/caret.c b/windows/caret.c
index 041eff0..99c955f 100644
--- a/windows/caret.c
+++ b/windows/caret.c
@@ -60,7 +60,7 @@
     Caret.on = !Caret.on;
     if (!(hdc = GetDCEx32( Caret.hwnd, 0, DCX_USESTYLE | DCX_CACHE ))) return;
     hPrevBrush = SelectObject32( hdc, Caret.hBrush );
-    PatBlt( hdc, Caret.x, Caret.y, Caret.width, Caret.height, PATINVERT );
+    PatBlt32( hdc, Caret.x, Caret.y, Caret.width, Caret.height, PATINVERT );
     SelectObject32( hdc, hPrevBrush );
     ReleaseDC32( Caret.hwnd, hdc );
 }
diff --git a/windows/dce.c b/windows/dce.c
index d83b8bb..5a7c9e0 100644
--- a/windows/dce.c
+++ b/windows/dce.c
@@ -331,8 +331,8 @@
         wndPtr = wndPtr->parent;
         xoffset -= wndPtr->rectClient.left;
         yoffset -= wndPtr->rectClient.top;
-        hrgn = DCE_ClipWindows( wndPtr->parent->child, wndPtr,
-                                hrgn, xoffset, yoffset );
+        hrgn = DCE_ClipWindows( wndPtr->parent ? wndPtr->parent->child : NULL,
+                                wndPtr, hrgn, xoffset, yoffset );
         if (!hrgn) return 0;
     }
     return hrgn;
diff --git a/windows/dialog.c b/windows/dialog.c
index 17a349a..03a0ddf 100644
--- a/windows/dialog.c
+++ b/windows/dialog.c
@@ -1320,3 +1320,143 @@
     }
     return pWndLast->hwndSelf;
 }
+
+
+/**********************************************************************
+ *           DIALOG_DlgDirSelect
+ *
+ * Helper function for DlgDirSelect*
+ */
+static BOOL32 DIALOG_DlgDirSelect( HWND32 hwnd, LPSTR str, INT32 len,
+                                   INT32 id, BOOL32 win32, BOOL32 unicode,
+                                   BOOL32 combo )
+{
+    char *buffer, *ptr;
+    INT32 item, size;
+    BOOL32 ret;
+    HWND32 listbox = GetDlgItem( hwnd, id );
+
+    dprintf_dialog( stddeb, "DlgDirSelect: %04x '%s' %d\n", hwnd, str, id );
+    if (!listbox) return FALSE;
+    if (win32)
+    {
+        item = SendMessage32A(listbox, combo ? CB_GETCURSEL32
+                                             : LB_GETCURSEL32, 0, 0 );
+        if (item == LB_ERR) return FALSE;
+        size = SendMessage32A(listbox, combo ? CB_GETLBTEXTLEN32
+                                             : LB_GETTEXTLEN32, 0, 0 );
+        if (size == LB_ERR) return FALSE;
+    }
+    else
+    {
+        item = SendMessage32A(listbox, combo ? CB_GETCURSEL16
+                                             : LB_GETCURSEL16, 0, 0 );
+        if (item == LB_ERR) return FALSE;
+        size = SendMessage32A(listbox, combo ? CB_GETLBTEXTLEN16
+                                             : LB_GETTEXTLEN16, 0, 0 );
+        if (size == LB_ERR) return FALSE;
+    }
+
+    if (!(buffer = SEGPTR_ALLOC( size+1 ))) return FALSE;
+
+    if (win32)
+        SendMessage32A( listbox, combo ? CB_GETLBTEXT32 : LB_GETTEXT32,
+                        item, (LPARAM)buffer );
+    else
+        SendMessage16( listbox, combo ? CB_GETLBTEXT16 : LB_GETTEXT16,
+                       item, (LPARAM)SEGPTR_GET(buffer) );
+
+    if ((ret = (buffer[0] == '[')))  /* drive or directory */
+    {
+        if (buffer[1] == '-')  /* drive */
+        {
+            buffer[3] = ':';
+            buffer[4] = 0;
+            ptr = buffer + 2;
+        }
+        else
+        {
+            buffer[strlen(buffer)-1] = '\\';
+            ptr = buffer + 1;
+        }
+    }
+    else ptr = buffer;
+
+    if (unicode) lstrcpynAtoW( (LPWSTR)str, ptr, len );
+    else lstrcpyn32A( str, ptr, len );
+    SEGPTR_FREE( buffer );
+    dprintf_dialog( stddeb, "Returning %d '%s'\n", ret, str );
+    return ret;
+}
+
+
+/**********************************************************************
+ *	    DlgDirSelect    (USER.99)
+ */
+BOOL16 DlgDirSelect( HWND16 hwnd, LPSTR str, INT16 id )
+{
+    return DlgDirSelectEx16( hwnd, str, 128, id );
+}
+
+
+/**********************************************************************
+ *	    DlgDirSelectComboBox    (USER.194)
+ */
+BOOL16 DlgDirSelectComboBox( HWND16 hwnd, LPSTR str, INT16 id )
+{
+    return DlgDirSelectComboBoxEx16( hwnd, str, 128, id );
+}
+
+
+/**********************************************************************
+ *           DlgDirSelectEx16    (USER.422)
+ */
+BOOL16 DlgDirSelectEx16( HWND16 hwnd, LPSTR str, INT16 len, INT16 id )
+{
+    return DIALOG_DlgDirSelect( hwnd, str, len, id, FALSE, FALSE, FALSE );
+}
+
+
+/**********************************************************************
+ *           DlgDirSelectEx32A    (USER32.148)
+ */
+BOOL32 DlgDirSelectEx32A( HWND32 hwnd, LPSTR str, INT32 len, INT32 id )
+{
+    return DIALOG_DlgDirSelect( hwnd, str, len, id, TRUE, FALSE, FALSE );
+}
+
+
+/**********************************************************************
+ *           DlgDirSelectEx32W    (USER32.149)
+ */
+BOOL32 DlgDirSelectEx32W( HWND32 hwnd, LPWSTR str, INT32 len, INT32 id )
+{
+    return DIALOG_DlgDirSelect( hwnd, (LPSTR)str, len, id, TRUE, TRUE, FALSE );
+}
+
+
+/**********************************************************************
+ *           DlgDirSelectComboBoxEx16    (USER.423)
+ */
+BOOL16 DlgDirSelectComboBoxEx16( HWND16 hwnd, LPSTR str, INT16 len, INT16 id )
+{
+    return DIALOG_DlgDirSelect( hwnd, str, len, id, FALSE, FALSE, TRUE );
+}
+
+
+/**********************************************************************
+ *           DlgDirSelectComboBoxEx32A    (USER32.146)
+ */
+BOOL32 DlgDirSelectComboBoxEx32A( HWND32 hwnd, LPSTR str, INT32 len, INT32 id )
+{
+    return DIALOG_DlgDirSelect( hwnd, str, len, id, TRUE, FALSE, TRUE );
+}
+
+
+/**********************************************************************
+ *           DlgDirSelectComboBoxEx32W    (USER32.147)
+ */
+BOOL32 DlgDirSelectComboBoxEx32W( HWND32 hwnd, LPWSTR str, INT32 len, INT32 id)
+{
+    return DIALOG_DlgDirSelect( hwnd, (LPSTR)str, len, id, TRUE, TRUE, TRUE );
+}
diff --git a/windows/event.c b/windows/event.c
index 24ec312..2010052 100644
--- a/windows/event.c
+++ b/windows/event.c
@@ -32,14 +32,30 @@
 #include "options.h"
 #include "queue.h"
 #include "winpos.h"
+#include "drive.h"
+#include "dos_fs.h"
+#include "shell.h"
 #include "registers.h"
 #include "xmalloc.h"
 #include "stddebug.h"
 #include "debug.h"
 #include "dde_proc.h"
 
+
 #define NB_BUTTONS      3     /* Windows can handle 3 buttons */
 
+#define DndNotDnd       -1    /* OffiX drag&drop */
+#define DndUnknown      0
+#define DndRawData      1
+#define DndFile         2
+#define DndFiles        3
+#define DndText         4
+#define DndDir          5
+#define DndLink         6
+#define DndExe          7
+
+#define DndEND          8
+
   /* X context to associate a hwnd to an X window */
 static XContext winContext = 0;
 
@@ -123,6 +139,11 @@
 
 static BOOL KeyDown = FALSE;
 
+static Atom wmProtocols = None;
+static Atom wmDeleteWindow = None;
+static Atom dndProtocol = None;
+static Atom dndSelection = None;
+
 static const char * const event_names[] =
 {
     "", "", "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease",
@@ -155,6 +176,9 @@
 static void EVENT_EnterNotify( WND *pWnd, XCrossingEvent *event );
 */
 
+extern void FOCUS_SetXFocus( HWND32 );
+extern BOOL16 DRAG_QueryUpdate( HWND, SEGPTR, BOOL32 );
+
 /***********************************************************************
  *           EVENT_ProcessEvent
  *
@@ -277,6 +301,15 @@
  */
 void EVENT_RegisterWindow( WND *pWnd )
 {
+    if (wmProtocols == None)
+        wmProtocols = XInternAtom( display, "WM_PROTOCOLS", True );
+    if (wmDeleteWindow == None)
+        wmDeleteWindow = XInternAtom( display, "WM_DELETE_WINDOW", True );
+    if( dndProtocol == None )
+	dndProtocol = XInternAtom( display, "DndProtocol" , False );
+    if( dndSelection == None )
+	dndSelection = XInternAtom( display, "DndSelection" , False );
+
     if (!winContext) winContext = XUniqueContext();
     XSaveContext( display, pWnd->window, winContext, (char *)pWnd );
 }
@@ -291,14 +324,18 @@
  */
 BOOL32 EVENT_WaitXEvent( BOOL32 sleep, BOOL32 peek )
 {
-    fd_set read_set;
-    struct timeval timeout;
     XEvent event;
-    int fd = ConnectionNumber(display);
+    LONG maxWait = sleep ? TIMER_GetNextExpiration() : 0;
 
-    if (!XPending(display))
+    /* Wait for an event or a timeout. If maxWait is -1, we have no timeout;
+     * in this case, we fall through directly to the XNextEvent loop.
+     */
+
+    if ((maxWait != -1) && !XPending(display))
     {
-        LONG maxWait = sleep ? TIMER_GetNextExpiration() : 0;
+        fd_set read_set;
+        struct timeval timeout;
+        int fd = ConnectionNumber(display);
 
         FD_ZERO( &read_set );
         FD_SET( fd, &read_set );
@@ -824,11 +861,11 @@
 	    /* remove carriage returns */
 
 	    lpstr = (char*)xmalloc(size--);
-	    for(i=0,j=0; i < size; i++ )
+	    for(i=0,j=0; i < size && text[i]; i++ )
 	    {
-	       if( text[i] == '\r' && text[i+1] == '\n' ) continue;
+	       if( text[i] == '\r' && 
+		  (text[i+1] == '\n' || text[i+1] == '\0') ) continue;
 	       lpstr[j++] = text[i];
-	       if( text[i] == '\0' ) break;
 	    }
 	    lpstr[j]='\0';
 
@@ -886,21 +923,121 @@
  */
 static void EVENT_ClientMessage( WND *pWnd, XClientMessageEvent *event )
 {
-    static Atom wmProtocols = None;
-    static Atom wmDeleteWindow = None;
-
-    if (wmProtocols == None)
-        wmProtocols = XInternAtom( display, "WM_PROTOCOLS", True );
-    if (wmDeleteWindow == None)
-        wmDeleteWindow = XInternAtom( display, "WM_DELETE_WINDOW", True );
-
-    if ((event->format != 32) || (event->message_type != wmProtocols) ||
-        (((Atom) event->data.l[0]) != wmDeleteWindow))
+    if (event->message_type != None && event->format == 32)
     {
-	dprintf_event( stddeb, "unrecognized ClientMessage\n" );
-	return;
+       if ((event->message_type == wmProtocols) && 
+           (((Atom) event->data.l[0]) == wmDeleteWindow))
+	  SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, 0 );
+       else if ( event->message_type == dndProtocol &&
+		(event->data.l[0] == DndFile || event->data.l[0] == DndFiles) )
+       {
+	  unsigned long		data_length;
+	  unsigned long		aux_long;
+	  unsigned char*	p_data = NULL;
+	  union {
+		   Atom		atom_aux;
+		   POINT32	pt_aux;
+		   BOOL16	bAccept;
+		   int		i;
+		}		u;
+	  int			x, y;
+	  HGLOBAL16		hDragInfo = GlobalAlloc16( GMEM_SHARE | GMEM_ZEROINIT, sizeof(DRAGINFO));
+	  LPDRAGINFO            lpDragInfo = (LPDRAGINFO) GlobalLock16(hDragInfo);
+	  SEGPTR		spDragInfo = (SEGPTR) WIN16_GlobalLock16(hDragInfo);
+	  Window		w_aux_root, w_aux_child;
+	  WND*			pDropWnd;
+	  
+          if( !lpDragInfo || !spDragInfo ) return;
+
+	  XQueryPointer( display, pWnd->window, &w_aux_root, &w_aux_child, 
+		 &x, &y, &u.pt_aux.x, &u.pt_aux.y, (unsigned int*)&aux_long);
+
+          lpDragInfo->hScope = pWnd->hwndSelf;
+          lpDragInfo->pt.x = (INT16)x; lpDragInfo->pt.y = (INT16)y;
+
+	  /* find out drop point and drop window */
+	  if( x < 0 || y < 0 ||
+	      x > (pWnd->rectWindow.right - pWnd->rectWindow.left) ||
+	      y > (pWnd->rectWindow.bottom - pWnd->rectWindow.top) )
+	  {   u.bAccept = pWnd->dwExStyle & WS_EX_ACCEPTFILES; x = y = 0; }
+	  else
+	  {
+	      u.bAccept = DRAG_QueryUpdate( pWnd->hwndSelf, spDragInfo, TRUE );
+	      x = lpDragInfo->pt.x; y = lpDragInfo->pt.y;
+	  }
+	  pDropWnd = WIN_FindWndPtr( lpDragInfo->hScope );
+	  GlobalFree16( hDragInfo );
+
+	  if( u.bAccept )
+	  {
+	      XGetWindowProperty( display, DefaultRootWindow(display),
+			      dndSelection, 0, 65535, FALSE,
+                              AnyPropertyType, &u.atom_aux, &u.pt_aux.y,
+		             &data_length, &aux_long, &p_data);
+
+	      if( !aux_long && p_data)	/* don't bother if > 64K */
+	      {
+		char*			p = (char*) p_data;
+		char*			p_filename,*p_drop;
+
+		aux_long = 0; 
+		while( *p )	/* calculate buffer size */
+		{
+		  p_drop = p;
+		  if((u.i = *p) != -1 ) 
+		      u.i = DRIVE_FindDriveRoot( (const char**)&p_drop );
+		  if( u.i == -1 ) *p = -1;	/* mark as "bad" */
+		  else
+		  {
+		      p_filename = (char*) DOSFS_GetDosTrueName( (const char*)p, TRUE );
+		      if( p_filename ) aux_long += strlen(p_filename) + 1;
+		      else *p = -1;
+		  }
+		  p += strlen(p) + 1;
+		}
+		if( aux_long && aux_long < 65535 )
+		{
+		  HDROP16                 hDrop;
+		  LPDROPFILESTRUCT        lpDrop;
+
+		  aux_long += sizeof(DROPFILESTRUCT) + 1; 
+		  hDrop = (HDROP16)GlobalAlloc16( GMEM_SHARE, aux_long );
+		  lpDrop = (LPDROPFILESTRUCT) GlobalLock16( hDrop );
+
+		  if( lpDrop )
+		  {
+		    lpDrop->wSize = sizeof(DROPFILESTRUCT);
+		    lpDrop->ptMousePos.x = (INT16)x;
+		    lpDrop->ptMousePos.y = (INT16)y;
+		    lpDrop->fInNonClientArea = (BOOL16) 
+			( x < (pDropWnd->rectClient.left - pDropWnd->rectWindow.left)  ||
+			  y < (pDropWnd->rectClient.top - pDropWnd->rectWindow.top)    ||
+			  x > (pDropWnd->rectClient.right - pDropWnd->rectWindow.left) ||
+			  y > (pDropWnd->rectClient.bottom - pDropWnd->rectWindow.top) );
+		    p_drop = ((char*)lpDrop) + sizeof(DROPFILESTRUCT);
+		    p = p_data;
+		    while(*p)
+		    {
+		      if( *p != -1 )	/* use only "good" entries */
+		      {
+			p_filename = (char*) DOSFS_GetDosTrueName( p, TRUE );
+			strcpy(p_drop, p_filename);
+			p_drop += strlen( p_filename ) + 1;
+		      }
+		      p += strlen(p) + 1;
+		    }
+		    *p_drop = '\0';
+		    PostMessage( pWnd->hwndSelf, WM_DROPFILES, (WPARAM16)hDrop, 0L );
+		  }
+	        }
+	      }
+	      if( p_data ) XFree(p_data);  
+
+	  } /* WS_EX_ACCEPTFILES */
+       } /* dndProtocol */
+       else
+	  dprintf_event( stddeb, "unrecognized ClientMessage\n" );
     }
-    SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, 0 );
 }
 
 /**********************************************************************
@@ -918,8 +1055,6 @@
   }
  */ 
 
-extern void FOCUS_SetXFocus( HWND32 );
-
 /**********************************************************************
  *		EVENT_MapNotify
  */
diff --git a/windows/graphics.c b/windows/graphics.c
index 78abec2..40d1c30 100644
--- a/windows/graphics.c
+++ b/windows/graphics.c
@@ -533,8 +533,8 @@
      */
 
     if (!(prevBrush = SelectObject16( hdc, hbrush ))) return 0;
-    PatBlt( hdc, rect->left, rect->top,
-	    rect->right - rect->left, rect->bottom - rect->top, PATCOPY );
+    PatBlt32( hdc, rect->left, rect->top,
+              rect->right - rect->left, rect->bottom - rect->top, PATCOPY );
     SelectObject16( hdc, prevBrush );
     return 1;
 }
@@ -548,8 +548,8 @@
     HBRUSH32 prevBrush;
 
     if (!(prevBrush = SelectObject32( hdc, hbrush ))) return 0;
-    PatBlt( hdc, rect->left, rect->top,
-	    rect->right - rect->left, rect->bottom - rect->top, PATCOPY );
+    PatBlt32( hdc, rect->left, rect->top,
+              rect->right - rect->left, rect->bottom - rect->top, PATCOPY );
     SelectObject32( hdc, prevBrush );
     return 1;
 }
@@ -560,8 +560,8 @@
  */
 void InvertRect16( HDC16 hdc, const RECT16 *rect )
 {
-    PatBlt( hdc, rect->left, rect->top,
-	    rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
+    PatBlt32( hdc, rect->left, rect->top,
+              rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
 }
 
 
@@ -570,8 +570,8 @@
  */
 void InvertRect32( HDC32 hdc, const RECT32 *rect )
 {
-    PatBlt( hdc, rect->left, rect->top,
-	    rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
+    PatBlt32( hdc, rect->left, rect->top,
+              rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
 }
 
 
@@ -596,15 +596,15 @@
     
     if (DC_SetupGCForBrush( dc ))
     {
-   	PatBlt( hdc, rect->left, rect->top, 1,
-	    rect->bottom - rect->top, PATCOPY );
-	PatBlt( hdc, rect->right - 1, rect->top, 1,
-	    rect->bottom - rect->top, PATCOPY );
-	PatBlt( hdc, rect->left, rect->top,
-	    rect->right - rect->left, 1, PATCOPY );
-	PatBlt( hdc, rect->left, rect->bottom - 1,
-	    rect->right - rect->left, 1, PATCOPY );
-	}    
+   	PatBlt32( hdc, rect->left, rect->top, 1,
+                  rect->bottom - rect->top, PATCOPY );
+	PatBlt32( hdc, rect->right - 1, rect->top, 1,
+                  rect->bottom - rect->top, PATCOPY );
+	PatBlt32( hdc, rect->left, rect->top,
+                  rect->right - rect->left, 1, PATCOPY );
+	PatBlt32( hdc, rect->left, rect->bottom - 1,
+                  rect->right - rect->left, 1, PATCOPY );
+    }
     SelectObject16( hdc, prevBrush );
     return 1;
 }
@@ -922,20 +922,20 @@
 			                  sysColorObjects.hbrushBtnHighlight );
     for (i = 0; i < highlight_size; i++)
     {
-	PatBlt( hdc, rect->left + i, rect->top,
-	        1, rect->bottom - rect->top - i, PATCOPY );
-	PatBlt( hdc, rect->left, rect->top + i,
-	        rect->right - rect->left - i, 1, PATCOPY );
+	PatBlt32( hdc, rect->left + i, rect->top,
+                  1, rect->bottom - rect->top - i, PATCOPY );
+	PatBlt32( hdc, rect->left, rect->top + i,
+                  rect->right - rect->left - i, 1, PATCOPY );
     }
 
     SelectObject32( hdc, pressed ? sysColorObjects.hbrushBtnHighlight :
 		                   sysColorObjects.hbrushBtnShadow );
     for (i = 0; i < shadow_size; i++)
     {
-	PatBlt( hdc, rect->right - i - 1, rect->top + i,
-	        1, rect->bottom - rect->top - i, PATCOPY );
-	PatBlt( hdc, rect->left + i, rect->bottom - i - 1,
-	        rect->right - rect->left - i, 1, PATCOPY );
+	PatBlt32( hdc, rect->right - i - 1, rect->top + i,
+                  1, rect->bottom - rect->top - i, PATCOPY );
+	PatBlt32( hdc, rect->left + i, rect->bottom - i - 1,
+                  rect->right - rect->left - i, 1, PATCOPY );
     }
 
     SelectObject32( hdc, hbrushOld );
@@ -1250,31 +1250,31 @@
     hbrushOld = SelectObject32( hdc, sysColorObjects.hbrushBtnHighlight );
     if (edge & BDR_RAISEDOUTER)
     {
-        if (flags & BF_LEFT) PatBlt( hdc, rc->left, rc->top,
-                                     1, rc->bottom - rc->top - 1, PATCOPY );
-        if (flags & BF_TOP) PatBlt( hdc, rc->left, rc->top,
-                                     rc->right - rc->left - 1, 1, PATCOPY );
+        if (flags & BF_LEFT) PatBlt32( hdc, rc->left, rc->top,
+                                       1, rc->bottom - rc->top - 1, PATCOPY );
+        if (flags & BF_TOP) PatBlt32( hdc, rc->left, rc->top,
+                                      rc->right - rc->left - 1, 1, PATCOPY );
     }
     if (edge & BDR_SUNKENOUTER)
     {
-        if (flags & BF_RIGHT) PatBlt( hdc, rc->right - 1, rc->top,
-                                      1, rc->bottom - rc->top, PATCOPY );
-        if (flags & BF_BOTTOM) PatBlt( hdc, rc->left, rc->bottom - 1,
-                                       rc->right - rc->left, 1, PATCOPY );
+        if (flags & BF_RIGHT) PatBlt32( hdc, rc->right - 1, rc->top,
+                                        1, rc->bottom - rc->top, PATCOPY );
+        if (flags & BF_BOTTOM) PatBlt32( hdc, rc->left, rc->bottom - 1,
+                                         rc->right - rc->left, 1, PATCOPY );
     }
     if (edge & BDR_RAISEDINNER)
     {
-        if (flags & BF_LEFT) PatBlt( hdc, rc->left + 1, rc->top + 1, 
-                                     1, rc->bottom - rc->top - 2, PATCOPY );
-        if (flags & BF_TOP) PatBlt( hdc, rc->left + 1, rc->top + 1,
-                                     rc->right - rc->left - 2, 1, PATCOPY );
+        if (flags & BF_LEFT) PatBlt32( hdc, rc->left + 1, rc->top + 1, 
+                                       1, rc->bottom - rc->top - 2, PATCOPY );
+        if (flags & BF_TOP) PatBlt32( hdc, rc->left + 1, rc->top + 1,
+                                      rc->right - rc->left - 2, 1, PATCOPY );
     }
     if (edge & BDR_SUNKENINNER)
     {
-        if (flags & BF_RIGHT) PatBlt( hdc, rc->right - 2, rc->top + 1,
-                                     1, rc->bottom - rc->top - 2, PATCOPY );
-        if (flags & BF_BOTTOM) PatBlt( hdc, rc->left + 1, rc->bottom - 2,
-                                       rc->right - rc->left - 2, 1, PATCOPY );
+        if (flags & BF_RIGHT) PatBlt32( hdc, rc->right - 2, rc->top + 1,
+                                        1, rc->bottom - rc->top - 2, PATCOPY );
+        if (flags & BF_BOTTOM) PatBlt32( hdc, rc->left + 1, rc->bottom - 2,
+                                         rc->right - rc->left - 2, 1, PATCOPY );
     }
 
     /* Then do all the sunken edges */
@@ -1282,31 +1282,31 @@
     SelectObject32( hdc, sysColorObjects.hbrushBtnShadow );
     if (edge & BDR_SUNKENOUTER)
     {
-        if (flags & BF_LEFT) PatBlt( hdc, rc->left, rc->top,
-                                     1, rc->bottom - rc->top - 1, PATCOPY );
-        if (flags & BF_TOP) PatBlt( hdc, rc->left, rc->top,
-                                     rc->right - rc->left - 1, 1, PATCOPY );
+        if (flags & BF_LEFT) PatBlt32( hdc, rc->left, rc->top,
+                                       1, rc->bottom - rc->top - 1, PATCOPY );
+        if (flags & BF_TOP) PatBlt32( hdc, rc->left, rc->top,
+                                      rc->right - rc->left - 1, 1, PATCOPY );
     }
     if (edge & BDR_RAISEDOUTER)
     {
-        if (flags & BF_RIGHT) PatBlt( hdc, rc->right - 1, rc->top,
-                                      1, rc->bottom - rc->top, PATCOPY );
-        if (flags & BF_BOTTOM) PatBlt( hdc, rc->left, rc->bottom - 1,
-                                       rc->right - rc->left, 1, PATCOPY );
+        if (flags & BF_RIGHT) PatBlt32( hdc, rc->right - 1, rc->top,
+                                        1, rc->bottom - rc->top, PATCOPY );
+        if (flags & BF_BOTTOM) PatBlt32( hdc, rc->left, rc->bottom - 1,
+                                         rc->right - rc->left, 1, PATCOPY );
     }
     if (edge & BDR_SUNKENINNER)
     {
-        if (flags & BF_LEFT) PatBlt( hdc, rc->left + 1, rc->top + 1, 
-                                     1, rc->bottom - rc->top - 2, PATCOPY );
-        if (flags & BF_TOP) PatBlt( hdc, rc->left + 1, rc->top + 1,
-                                     rc->right - rc->left - 2, 1, PATCOPY );
+        if (flags & BF_LEFT) PatBlt32( hdc, rc->left + 1, rc->top + 1, 
+                                       1, rc->bottom - rc->top - 2, PATCOPY );
+        if (flags & BF_TOP) PatBlt32( hdc, rc->left + 1, rc->top + 1,
+                                      rc->right - rc->left - 2, 1, PATCOPY );
     }
     if (edge & BDR_RAISEDINNER)
     {
-        if (flags & BF_RIGHT) PatBlt( hdc, rc->right - 2, rc->top + 1,
-                                     1, rc->bottom - rc->top - 2, PATCOPY );
-        if (flags & BF_BOTTOM) PatBlt( hdc, rc->left + 1, rc->bottom - 2,
-                                       rc->right - rc->left - 2, 1, PATCOPY );
+        if (flags & BF_RIGHT) PatBlt32( hdc, rc->right - 2, rc->top + 1,
+                                        1, rc->bottom - rc->top - 2, PATCOPY );
+        if (flags & BF_BOTTOM) PatBlt32( hdc, rc->left + 1, rc->bottom - 2,
+                                         rc->right - rc->left - 2, 1, PATCOPY );
     }
 
     SelectObject32( hdc, hbrushOld );
diff --git a/windows/mdi.c b/windows/mdi.c
index 1e6b45f..684b3fc 100644
--- a/windows/mdi.c
+++ b/windows/mdi.c
@@ -672,8 +672,8 @@
  hbCopy = CreateCompatibleBitmap(hDCSrc,SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE);
  hb_dest = SelectObject32(hDCDest,hbCopy);
 
- BitBlt(hDCDest, 0, 0, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
-	hDCSrc, SYSMETRICS_CXSIZE, 0, SRCCOPY);
+ BitBlt32(hDCDest, 0, 0, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
+          hDCSrc, SYSMETRICS_CXSIZE, 0, SRCCOPY);
  
  SelectObject32(hDCSrc,hb_src);
  SelectObject32(hDCDest,hb_dest);
@@ -982,7 +982,8 @@
     RECT16		 rect;
     WND                 *w 	  = WIN_FindWndPtr(hwnd);
     WND			*frameWnd = w->parent;
-
+    INT			nItems;
+    
     ci = (MDICLIENTINFO *) w->wExtra;
     
     switch (message)
@@ -1020,12 +1021,12 @@
       
       case WM_DESTROY:
 	if( ci->hwndChildMaximized ) MDI_RestoreFrameMenu(w, frameWnd->hwndSelf);
-	ci->idFirstChild = GetMenuItemCount(ci->hWindowMenu) - 1;
-	ci->nActiveChildren++; 			/* to delete a separator */
-
-	while( ci->nActiveChildren-- )
-	     DeleteMenu(ci->hWindowMenu,MF_BYPOSITION,ci->idFirstChild--);
-
+	if((nItems = GetMenuItemCount(ci->hWindowMenu)) > 0) {
+    	    ci->idFirstChild = nItems - 1;
+	    ci->nActiveChildren++; 		/* to delete a separator */
+	    while( ci->nActiveChildren-- )
+	        DeleteMenu(ci->hWindowMenu,MF_BYPOSITION,ci->idFirstChild--);
+	}
 	return 0;
 
       case WM_MDIACTIVATE:
@@ -1718,8 +1719,8 @@
  SetScrollPos32(hWnd, (uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ , newPos, TRUE);
 
  if( uMsg == WM_VSCROLL )
-     ScrollWindow(hWnd ,0 ,curPos - newPos, NULL, NULL);
+     ScrollWindow32(hWnd ,0 ,curPos - newPos, NULL, NULL);
  else
-     ScrollWindow(hWnd ,curPos - newPos, 0, NULL, NULL);
+     ScrollWindow32(hWnd ,curPos - newPos, 0, NULL, NULL);
 }
 
diff --git a/windows/message.c b/windows/message.c
index 3e5f253..4ac32f3 100644
--- a/windows/message.c
+++ b/windows/message.c
@@ -105,7 +105,7 @@
         return ret ? SYSQ_MSG_ACCEPT : SYSQ_MSG_SKIP ;
     }
    
-    hittest = WINPOS_WindowFromPoint( msg->pt, &pWnd );
+    hittest = WINPOS_WindowFromPoint( WIN_GetDesktop(), msg->pt, &pWnd );
     if (pWnd->hmemTaskQ != GetTaskQueue(0))
     {
         /* Not for the current task */
diff --git a/windows/nonclient.c b/windows/nonclient.c
index ec0c986..d7f70cb 100644
--- a/windows/nonclient.c
+++ b/windows/nonclient.c
@@ -56,6 +56,8 @@
 #define ON_BOTTOM_BORDER(hit) \
  (((hit) == HTBOTTOM) || ((hit) == HTBOTTOMLEFT) || ((hit) == HTBOTTOMRIGHT))
 
+extern HCURSOR16 CURSORICON_IconToCursor( HICON16, BOOL32 );
+
 /***********************************************************************
  *           NC_AdjustRect
  *
@@ -443,9 +445,9 @@
       NC_GetInsideRect( hwnd, &rect );
       hdcMem = CreateCompatibleDC( hdc );
       hbitmap = SelectObject32( hdcMem, hbitmapClose );
-      BitBlt( hdc, rect.left, rect.top, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
-              hdcMem, (wndPtr->dwStyle & WS_CHILD) ? SYSMETRICS_CXSIZE : 0, 0,
-              down ? NOTSRCCOPY : SRCCOPY );
+      BitBlt32(hdc, rect.left, rect.top, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
+               hdcMem, (wndPtr->dwStyle & WS_CHILD) ? SYSMETRICS_CXSIZE : 0, 0,
+               down ? NOTSRCCOPY : SRCCOPY );
       SelectObject32( hdcMem, hbitmap );
       DeleteDC( hdcMem );
     }
@@ -517,14 +519,14 @@
     }
 
       /* Draw frame */
-    PatBlt( hdc, rect->left, rect->top,
-	    rect->right - rect->left, height, PATCOPY );
-    PatBlt( hdc, rect->left, rect->top,
-	    width, rect->bottom - rect->top, PATCOPY );
-    PatBlt( hdc, rect->left, rect->bottom,
-	    rect->right - rect->left, -height, PATCOPY );
-    PatBlt( hdc, rect->right, rect->top,
-	    -width, rect->bottom - rect->top, PATCOPY );
+    PatBlt32( hdc, rect->left, rect->top,
+              rect->right - rect->left, height, PATCOPY );
+    PatBlt32( hdc, rect->left, rect->top,
+              width, rect->bottom - rect->top, PATCOPY );
+    PatBlt32( hdc, rect->left, rect->bottom,
+              rect->right - rect->left, -height, PATCOPY );
+    PatBlt32( hdc, rect->right, rect->top,
+              -width, rect->bottom - rect->top, PATCOPY );
 
     if (dlgFrame)
     {
@@ -575,21 +577,8 @@
  */
 static void NC_DrawMovingFrame( HDC16 hdc, RECT16 *rect, BOOL thickframe )
 {
-    if (thickframe)
-    {
-	SelectObject32( hdc, GetStockObject32( GRAY_BRUSH ) );
-	PatBlt( hdc, rect->left, rect->top,
-	        rect->right - rect->left - SYSMETRICS_CXFRAME,
-	        SYSMETRICS_CYFRAME, PATINVERT );
-	PatBlt( hdc, rect->left, rect->top + SYSMETRICS_CYFRAME,
-	        SYSMETRICS_CXFRAME, 
-	        rect->bottom - rect->top - SYSMETRICS_CYFRAME, PATINVERT );
-	PatBlt( hdc, rect->left + SYSMETRICS_CXFRAME, rect->bottom,
-	        rect->right - rect->left - SYSMETRICS_CXFRAME,
-	        -SYSMETRICS_CYFRAME, PATINVERT );
-	PatBlt( hdc, rect->right, rect->top, -SYSMETRICS_CXFRAME, 
-	        rect->bottom - rect->top - SYSMETRICS_CYFRAME, PATINVERT );
-    }
+    if (thickframe) FastWindowFrame( hdc, rect, SYSMETRICS_CXFRAME,
+                                     SYSMETRICS_CYFRAME, PATINVERT );
     else DrawFocusRect16( hdc, rect );
 }
 
@@ -624,9 +613,9 @@
     if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
     {
 	HBRUSH32 hbrushOld = SelectObject32(hdc, sysColorObjects.hbrushWindow);
-	PatBlt( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
-	PatBlt( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
-	PatBlt( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
+	PatBlt32( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
+	PatBlt32( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
+	PatBlt32( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
 	r.left++;
 	r.right--;
 	SelectObject32( hdc, hbrushOld );
@@ -992,18 +981,18 @@
 static void NC_DoSizeMove( HWND hwnd, WORD wParam, POINT16 pt )
 {
     MSG16 msg;
-    LONG hittest;
     RECT16 sizingRect, mouseRect;
     HDC32 hdc;
-    BOOL thickframe;
-    POINT16 minTrack, maxTrack, capturePoint = pt;
-    WND * wndPtr = WIN_FindWndPtr( hwnd );
-    int moved = 0;
+    LONG hittest = (LONG)(wParam & 0x0f);
+    HCURSOR16 hDragCursor = 0, hOldCursor = 0;
+    POINT16   minTrack, maxTrack, capturePoint = pt;
+    WND *     wndPtr = WIN_FindWndPtr( hwnd );
+    BOOL32    thickframe = HAS_THICKFRAME( wndPtr->dwStyle );
+    BOOL32    iconic = wndPtr->dwStyle & WS_MINIMIZE;
+    int       moved = 0;
 
     if (IsZoomed(hwnd) || !IsWindowVisible(hwnd) ||
         (wndPtr->flags & WIN_MANAGED)) return;
-    hittest = wParam & 0x0f;
-    thickframe = HAS_THICKFRAME( wndPtr->dwStyle );
 
     if ((wParam & 0xfff0) == SC_MOVE)
     {
@@ -1068,7 +1057,21 @@
 	hdc = GetDC32( 0 );
 	if (rootWindow == DefaultRootWindow(display)) XGrabServer( display );
     }
-    NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
+
+    if( iconic )
+    {
+      HICON16 hIcon = (wndPtr->class->hIcon)
+                      ? wndPtr->class->hIcon
+                      : (HICON16)SendMessage16( hwnd, WM_QUERYDRAGICON, 0, 0L);
+      if( hIcon )
+      {
+        hDragCursor =  CURSORICON_IconToCursor( hIcon, TRUE );
+        hOldCursor = SetCursor(hDragCursor);
+        ShowCursor(1);
+      } else iconic = FALSE;
+    }
+
+    if( !iconic ) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
 
     while(1)
     {
@@ -1117,16 +1120,26 @@
 		else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
 		if (ON_TOP_BORDER(hittest)) newRect.top += dy;
 		else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
-		NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
-		NC_DrawMovingFrame( hdc, &newRect, thickframe );
+		if( !iconic )
+		{
+		  NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
+		  NC_DrawMovingFrame( hdc, &newRect, thickframe );
+		}
 		capturePoint = pt;
 		sizingRect = newRect;
 	    }
 	}
     }
 
-    NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
     ReleaseCapture();
+    if( iconic )
+    {
+      ShowCursor(0);
+      SetCursor(hOldCursor);
+      if( hDragCursor ) DestroyCursor(hDragCursor);
+    }
+    else
+      NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
 
     if (wndPtr->dwStyle & WS_CHILD)
         ReleaseDC32( wndPtr->parent->hwndSelf, hdc );
diff --git a/windows/painting.c b/windows/painting.c
index 3edfe8a..b41a6e9 100644
--- a/windows/painting.c
+++ b/windows/painting.c
@@ -115,8 +115,14 @@
      * (because rectClient == rectWindow for WS_MINIMIZE windows).
      */
 
-    lps->hdc = GetDCEx16(hwnd, hrgnUpdate, DCX_INTERSECTRGN | DCX_WINDOWPAINT |
-                         DCX_USESTYLE | (bIcon ? DCX_WINDOW : 0) );
+    if (wndPtr->class->style & CS_PARENTDC)
+        /* Don't clip the output to the update region for CS_PARENTDC window */
+        lps->hdc = GetDCEx16( hwnd, 0, DCX_WINDOWPAINT | DCX_USESTYLE |
+                              (bIcon ? DCX_WINDOW : 0) );
+    else
+        lps->hdc = GetDCEx16(hwnd, hrgnUpdate, DCX_INTERSECTRGN |
+                             DCX_WINDOWPAINT | DCX_USESTYLE |
+                             (bIcon ? DCX_WINDOW : 0) );
 
     dprintf_win(stddeb,"hdc = %04x\n", lps->hdc);
 
@@ -264,13 +270,7 @@
                      hwnd, hrgnUpdate, flags);
     }
 
-    if (wndPtr->class->style & CS_PARENTDC)
-    {
-        GetClientRect32( wndPtr->parent->hwndSelf, &rectClient );
-        OffsetRect32( &rectClient, -wndPtr->rectClient.left,
-                      -wndPtr->rectClient.top );
-    }
-    else GetClientRect32( hwnd, &rectClient );
+    GetClientRect32( hwnd, &rectClient );
 
     if (flags & RDW_INVALIDATE)  /* Invalidate */
     {
@@ -410,23 +410,16 @@
            for (wndPtr = wndPtr->child; wndPtr; wndPtr = wndPtr->next)
 	     if( wndPtr->dwStyle & WS_VISIBLE )
 	       {
-                   if (wndPtr->class->style & CS_PARENTDC)
-                   {
-                       if (!CombineRgn32( hrgn, hrgnUpdate, 0, RGN_COPY ))
-                           continue;
-                   }
-                   else
-                   {
-                       SetRectRgn( hrgn, wndPtr->rectWindow.left,
-                                   wndPtr->rectWindow.top,
-                                   wndPtr->rectWindow.right,
-                                   wndPtr->rectWindow.bottom );
-                       if (!CombineRgn32( hrgn, hrgn, hrgnUpdate, RGN_AND ))
-                           continue;
-                   }
+                   SetRectRgn( hrgn, wndPtr->rectWindow.left,
+                               wndPtr->rectWindow.top,
+                               wndPtr->rectWindow.right,
+                               wndPtr->rectWindow.bottom );
+                   if (!CombineRgn32( hrgn, hrgn, hrgnUpdate, RGN_AND ))
+                       continue;
                    OffsetRgn32( hrgn, -wndPtr->rectClient.left,
                                       -wndPtr->rectClient.top );
-                   PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, hrgn, flags, RDW_C_USEHRGN );
+                   PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, hrgn, flags,
+                                       RDW_C_USEHRGN );
                }
 	   DeleteObject32( hrgn );
 	   if (control & RDW_C_DELETEHRGN) DeleteObject32( hrgnUpdate );
diff --git a/windows/scroll.c b/windows/scroll.c
index b26ba15..71ecc98 100644
--- a/windows/scroll.c
+++ b/windows/scroll.c
@@ -7,6 +7,7 @@
  *
  */
 
+#define NO_TRANSITION_TYPES  /* This file is Win32-clean */
 #include <stdlib.h>
 #include "wintypes.h"
 #include "class.h"
@@ -15,38 +16,54 @@
 #include "region.h"
 #include "sysmetrics.h"
 #include "stddebug.h"
-/* #define DEBUG_SCROLL */
 #include "debug.h"
 
-extern HWND CARET_GetHwnd();			/* windows/caret.c */
+extern HWND32 CARET_GetHwnd();			/* windows/caret.c */
 extern void CLIPPING_UpdateGCRegion(DC* );	/* objects/clipping.c */
 
 static int RgnType;
 
+
 /*************************************************************************
- *             ScrollWindow         (USER.61)
- *
+ *             ScrollWindow16   (USER.61)
  */
-void ScrollWindow(HWND hwnd, short dx, short dy, LPRECT16 rect, LPRECT16 clipRect)
+void ScrollWindow16( HWND16 hwnd, INT16 dx, INT16 dy, const RECT16 *rect,
+                     const RECT16 *clipRect )
+{
+    RECT32 rect32, clipRect32;
+
+    if (rect) CONV_RECT16TO32( rect, &rect32 );
+    if (clipRect) CONV_RECT16TO32( clipRect, &clipRect32 );
+    ScrollWindow32( hwnd, dx, dy, rect ? &rect32 : NULL,
+                    clipRect ? &clipRect32 : NULL );
+}
+
+
+/*************************************************************************
+ *             ScrollWindow32   (USER32.449)
+ */
+BOOL32 ScrollWindow32( HWND32 hwnd, INT32 dx, INT32 dy, const RECT32 *rect,
+                       const RECT32 *clipRect )
 {
     HDC32  	hdc;
     HRGN32 	hrgnUpdate,hrgnClip;
-    RECT16 	rc, cliprc;
-    HWND 	hCaretWnd = CARET_GetHwnd();
+    RECT32 	rc, cliprc;
+    HWND32 	hCaretWnd = CARET_GetHwnd();
     WND*	wndScroll = WIN_FindWndPtr( hwnd );
 
-    dprintf_scroll(stddeb,"ScrollWindow: hwnd=%04x, dx=%d, dy=%d, lpRect =%08lx clipRect=%i,%i,%i,%i\n", 
-	    hwnd, dx, dy, (LONG)rect, (int)((clipRect)?clipRect->left:0),
-                                (int)((clipRect)?clipRect->top:0),
-                                (int)((clipRect)?clipRect->right:0), 
-                                (int)((clipRect)?clipRect->bottom:0));
+    dprintf_scroll(stddeb,"ScrollWindow: hwnd=%04x, dx=%d, dy=%d, lpRect =%p clipRect=%i,%i,%i,%i\n", 
+                   hwnd, dx, dy, rect,
+                   clipRect ? clipRect->left : 0,
+                   clipRect ? clipRect->top : 0,
+                   clipRect ? clipRect->right : 0, 
+                   clipRect ? clipRect->bottom : 0 );
 
-    if ( !wndScroll || !WIN_IsWindowDrawable( wndScroll, TRUE ) ) return;
+    if ( !wndScroll || !WIN_IsWindowDrawable( wndScroll, TRUE ) ) return TRUE;
 
     if ( !rect ) /* do not clip children */
        {
-	  GetClientRect16(hwnd, &rc);
-	  hrgnClip = CreateRectRgnIndirect16( &rc );
+	  GetClientRect32(hwnd, &rc);
+	  hrgnClip = CreateRectRgnIndirect32( &rc );
 
           if ((hCaretWnd == hwnd) || IsChild(hwnd,hCaretWnd))
               HideCaret(hCaretWnd);
@@ -57,22 +74,21 @@
        }
     else	/* clip children */
        {
-	  GetClientRect16(hwnd,&rc);
-	  CopyRect16(&rc, rect);
+	  CopyRect32(&rc, rect);
 
           if (hCaretWnd == hwnd) HideCaret(hCaretWnd);
           else hCaretWnd = 0;
 
-	  hdc = GetDC32(hwnd);
+	  hdc = GetDCEx32( hwnd, 0, DCX_CACHE | DCX_USESTYLE );
        }
 
     if (clipRect == NULL)
-	GetClientRect16(hwnd, &cliprc);
+	GetClientRect32(hwnd, &cliprc);
     else
-	CopyRect16(&cliprc, clipRect);
+	CopyRect32(&cliprc, clipRect);
 
     hrgnUpdate = CreateRectRgn32( 0, 0, 0, 0 );
-    ScrollDC(hdc, dx, dy, &rc, &cliprc, hrgnUpdate, NULL);
+    ScrollDC32( hdc, dx, dy, &rc, &cliprc, hrgnUpdate, NULL );
     ReleaseDC32(hwnd, hdc);
 
     if( !rect )		/* move child windows and update region */
@@ -94,21 +110,39 @@
 
     DeleteObject32( hrgnUpdate );
     if( hCaretWnd ) ShowCaret(hCaretWnd);
+    return TRUE;
 }
 
 
 /*************************************************************************
- *             ScrollDC         (USER.221)
- *
+ *             ScrollDC16   (USER.221)
  */
-BOOL ScrollDC(HDC16 hdc, short dx, short dy, LPRECT16 rc, LPRECT16 cliprc,
-	      HRGN32 hrgnUpdate, LPRECT16 rcUpdate)
+BOOL16 ScrollDC16( HDC16 hdc, INT16 dx, INT16 dy, const RECT16 *rect,
+                   const RECT16 *cliprc, HRGN16 hrgnUpdate, LPRECT16 rcUpdate )
+{
+    RECT32 rect32, clipRect32, rcUpdate32;
+    BOOL16 ret;
+
+    if (rect) CONV_RECT16TO32( rect, &rect32 );
+    if (cliprc) CONV_RECT16TO32( cliprc, &clipRect32 );
+    ret = ScrollDC32( hdc, dx, dy, rect ? &rect32 : NULL,
+                      cliprc ? &clipRect32 : NULL, hrgnUpdate, &rcUpdate32 );
+    if (rcUpdate) CONV_RECT32TO16( &rcUpdate32, rcUpdate );
+    return ret;
+}
+
+
+/*************************************************************************
+ *             ScrollDC32   (USER32.448)
+ */
+BOOL32 ScrollDC32( HDC32 hdc, INT32 dx, INT32 dy, const RECT32 *rc,
+                   const RECT32 *cliprc, HRGN32 hrgnUpdate, LPRECT32 rcUpdate )
 {
     HRGN32 hrgnClip = 0;
     HRGN32 hrgnScrollClip = 0;
-    RECT16	rectClip;
-    POINT16 	src, dest;
-    short width, height;
+    RECT32 rectClip;
+    POINT32 src, dest;
+    INT32 width, height;
     DC *dc = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
 
     dprintf_scroll(stddeb,"ScrollDC: dx=%d dy=%d, hrgnUpdate=%04x rcUpdate = %p cliprc = %p, rc=%d %d %d %d\n",
@@ -119,17 +153,17 @@
 
     /* set clipping region */
 
-    if ( !rc ) GetClipBox16( hdc, &rectClip );
+    if ( !rc ) GetClipBox32( hdc, &rectClip );
     else rectClip = *rc;
 
     if (cliprc)
-	IntersectRect16(&rectClip,&rectClip,cliprc);
+	IntersectRect32(&rectClip,&rectClip,cliprc);
 
     if( rectClip.left >= rectClip.right || rectClip.top >= rectClip.bottom )
 	return FALSE;
     
     hrgnClip = GetClipRgn(hdc);
-    hrgnScrollClip = CreateRectRgnIndirect16(&rectClip);
+    hrgnScrollClip = CreateRectRgnIndirect32(&rectClip);
 
     if( hrgnClip )
       {
@@ -142,7 +176,7 @@
 	CLIPPING_UpdateGCRegion( dc );
       }
     else
-        SelectClipRgn16( hdc, hrgnScrollClip );
+        SelectClipRgn32( hdc, hrgnScrollClip );
 
     /* translate coordinates */
 
@@ -172,8 +206,8 @@
 
     /* copy bits */
 
-    if (!BitBlt(hdc, dest.x, dest.y, width, height, hdc, src.x, src.y, 
-		SRCCOPY))
+    if (!BitBlt32( hdc, dest.x, dest.y, width, height, hdc, src.x, src.y, 
+                   SRCCOPY))
 	return FALSE;
 
     /* compute update areas */
@@ -195,23 +229,23 @@
 	}
 	else
 	{
-	  RECT16	rect;
+	  RECT32 rect;
 
           rect = rectClip;				/* vertical band */
           if (dx > 0) rect.right = rect.left + dx;
           else if (dx < 0) rect.left = rect.right + dx;
-          else SetRectEmpty16( &rect );
+          else SetRectEmpty32( &rect );
           SetRectRgn( hrgn1, rect.left, rect.top, rect.right, rect.bottom );
 
           rect = rectClip;				/* horizontal band */
           if (dy > 0) rect.bottom = rect.top + dy;
           else if (dy < 0) rect.top = rect.bottom + dy;
-          else SetRectEmpty16( &rect );
+          else SetRectEmpty32( &rect );
 
           RgnType = REGION_UnionRectWithRgn( hrgn1, &rect );
 	}
 
-	if (rcUpdate) GetRgnBox16( hrgn1, rcUpdate );
+	if (rcUpdate) GetRgnBox32( hrgn1, rcUpdate );
 	if (!hrgnUpdate) DeleteObject32( hrgn1 );
     }
 
@@ -225,32 +259,55 @@
 
 
 /*************************************************************************
- *             ScrollWindowEx       (USER.319)
+ *             ScrollWindowEx16   (USER.319)
+ */
+INT16 ScrollWindowEx16( HWND16 hwnd, INT16 dx, INT16 dy, const RECT16 *rect,
+                        const RECT16 *clipRect, HRGN16 hrgnUpdate,
+                        LPRECT16 rcUpdate, UINT16 flags )
+{
+    RECT32 rect32, clipRect32, rcUpdate32;
+    BOOL16 ret;
+
+    if (rect) CONV_RECT16TO32( rect, &rect32 );
+    if (clipRect) CONV_RECT16TO32( clipRect, &clipRect32 );
+    ret = ScrollWindowEx32( hwnd, dx, dy, rect ? &rect32 : NULL,
+                            clipRect ? &clipRect32 : NULL, hrgnUpdate,
+                            &rcUpdate32, flags );
+    if (rcUpdate) CONV_RECT32TO16( &rcUpdate32, rcUpdate );
+    return ret;
+}
+
+
+/*************************************************************************
+ *             ScrollWindowEx32   (USER32.450)
  *
  * FIXME: broken, is there a program that actually uses it?
  *
  */
-
-int ScrollWindowEx(HWND hwnd, short dx, short dy, LPRECT16 rect, LPRECT16 clipRect,
-		   HRGN32 hrgnUpdate, LPRECT16 rcUpdate, WORD flags)
+INT32 ScrollWindowEx32( HWND32 hwnd, INT32 dx, INT32 dy, const RECT32 *rect,
+                        const RECT32 *clipRect, HRGN32 hrgnUpdate,
+                        LPRECT32 rcUpdate, UINT32 flags )
 {
     HDC32 hdc;
-    RECT16 rc, cliprc;
+    RECT32 rc, cliprc;
 
-    dprintf_scroll(stddeb,"ScrollWindowEx: dx=%d, dy=%d, wFlags=%04x\n",dx, dy, flags);
+    fprintf( stderr, "ScrollWindowEx: not fully implemented\n" );
+
+    dprintf_scroll(stddeb,"ScrollWindowEx: dx=%d, dy=%d, wFlags=%04x\n",
+                   dx, dy, flags);
 
     hdc = GetDC32(hwnd);
 
     if (rect == NULL)
-	GetClientRect16(hwnd, &rc);
+	GetClientRect32(hwnd, &rc);
     else
-	CopyRect16(&rc, rect);
+	CopyRect32(&rc, rect);
     if (clipRect == NULL)
-	GetClientRect16(hwnd, &cliprc);
+	GetClientRect32(hwnd, &cliprc);
     else
-	CopyRect16(&cliprc, clipRect);
+	CopyRect32(&cliprc, clipRect);
 
-    ScrollDC(hdc, dx, dy, &rc, &cliprc, hrgnUpdate, rcUpdate);
+    ScrollDC32( hdc, dx, dy, &rc, &cliprc, hrgnUpdate, rcUpdate );
 
     if (flags | SW_INVALIDATE)
     {
diff --git a/windows/win.c b/windows/win.c
index 0221627..f9b70ee 100644
--- a/windows/win.c
+++ b/windows/win.c
@@ -43,7 +43,7 @@
 static WORD wDragWidth = 4;
 static WORD wDragHeight= 3;
 
-extern HCURSOR16 CURSORICON_IconToCursor(HICON16);
+extern HCURSOR16 CURSORICON_IconToCursor(HICON16, BOOL32);
 extern HWND32 CARET_GetHwnd(void);
 extern BOOL32 WINPOS_ActivateOtherWindow(WND* pWnd);
 extern void   WINPOS_CheckActive(HWND32);
@@ -311,6 +311,8 @@
     HWND hwnd = wndPtr->hwndSelf;
     WND* pWnd,*pNext;
 
+    dprintf_win( stddeb, "WIN_DestroyWindow: %04x\n", wndPtr->hwndSelf );
+
 #ifdef CONFIG_IPC
     if (main_block)
 	DDE_DestroyWindow(wndPtr->hwndSelf);
@@ -659,7 +661,6 @@
     if (!(cs->style & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
     {
         XSetWindowAttributes win_attr;
-        Atom XA_WM_DELETE_WINDOW;
 
 	if (Options.managed && ((cs->style & (WS_DLGFRAME | WS_THICKFRAME)) ||
             (cs->dwExStyle & WS_EX_DLGMODALFRAME)))
@@ -689,9 +690,6 @@
                                         CWEventMask | CWOverrideRedirect |
                                         CWColormap | CWCursor | CWSaveUnder |
                                         CWBackingStore, &win_attr );
-	XA_WM_DELETE_WINDOW = XInternAtom( display, "WM_DELETE_WINDOW",
-					   False );
-	XSetWMProtocols( display, wndPtr->window, &XA_WM_DELETE_WINDOW, 1 );
 
         if ((wndPtr->flags & WIN_MANAGED) &&
             (cs->dwExStyle & WS_EX_DLGMODALFRAME))
@@ -2069,13 +2067,13 @@
  * recursively find a child that contains spDragInfo->pt point 
  * and send WM_QUERYDROPOBJECT
  */
-BOOL DRAG_QueryUpdate( HWND hQueryWnd, SEGPTR spDragInfo )
+BOOL16 DRAG_QueryUpdate( HWND hQueryWnd, SEGPTR spDragInfo, BOOL32 bNoSend )
 {
- BOOL		wParam,bResult = 0;
+ BOOL16		wParam,bResult = 0;
  POINT16        pt;
  LPDRAGINFO	ptrDragInfo = (LPDRAGINFO) PTR_SEG_TO_LIN(spDragInfo);
  WND 	       *ptrQueryWnd = WIN_FindWndPtr(hQueryWnd),*ptrWnd;
- RECT16		tempRect;	/* this sucks */
+ RECT16		tempRect;
 
  if( !ptrQueryWnd || !ptrDragInfo ) return 0;
 
@@ -2112,7 +2110,7 @@
                         ptrWnd->hwndSelf, ptrWnd->rectWindow.left, ptrWnd->rectWindow.top,
 			ptrWnd->rectWindow.right, ptrWnd->rectWindow.bottom );
             if( !(ptrWnd->dwStyle & WS_DISABLED) )
-	        bResult = DRAG_QueryUpdate(ptrWnd->hwndSelf, spDragInfo);
+	        bResult = DRAG_QueryUpdate(ptrWnd->hwndSelf, spDragInfo, bNoSend);
          }
 
 	 if(bResult) return bResult;
@@ -2125,7 +2123,9 @@
 
  ptrDragInfo->hScope = hQueryWnd;
 
- bResult = SendMessage16( hQueryWnd ,WM_QUERYDROPOBJECT ,
+ bResult = ( bNoSend ) 
+	   ? ptrQueryWnd->dwExStyle & WS_EX_ACCEPTFILES
+	   : SendMessage16( hQueryWnd ,WM_QUERYDROPOBJECT ,
                           (WPARAM16)wParam ,(LPARAM) spDragInfo );
  if( !bResult ) 
       ptrDragInfo->pt = pt;
@@ -2191,7 +2191,7 @@
  short	 	dragDone = 0;
  HCURSOR16	hCurrentCursor = 0;
  HWND		hCurrentWnd = 0;
- WORD	        btemp;
+ BOOL16		b;
 
  lpDragInfo = (LPDRAGINFO) GlobalLock16(hDragInfo);
  spDragInfo = (SEGPTR) WIN16_GlobalLock16(hDragInfo);
@@ -2208,7 +2208,7 @@
 
  if(hCursor)
    {
-	if( !(hDragCursor = CURSORICON_IconToCursor(hCursor)) )
+	if( !(hDragCursor = CURSORICON_IconToCursor(hCursor, FALSE)) )
 	  {
 	   GlobalFree16(hDragInfo);
 	   return 0L;
@@ -2244,7 +2244,7 @@
     /* update DRAGINFO struct */
     dprintf_msg(stddeb,"drag: lpDI->hScope = %04x\n",lpDragInfo->hScope);
 
-    if( (btemp = (WORD)DRAG_QueryUpdate(hwndScope, spDragInfo)) > 0 )
+    if( (b = DRAG_QueryUpdate(hwndScope, spDragInfo, FALSE)) > 0 )
 	 hCurrentCursor = hCursor;
     else
         {
@@ -2254,7 +2254,7 @@
     if( hCurrentCursor )
         SetCursor(hCurrentCursor);
 
-    dprintf_msg(stddeb,"drag: got %04x\n",btemp);
+    dprintf_msg(stddeb,"drag: got %04x\n", b);
 
     /* send WM_DRAGLOOP */
     SendMessage16( hWnd, WM_DRAGLOOP, (WPARAM16)(hCurrentCursor != hBummer) , 
diff --git a/windows/winpos.c b/windows/winpos.c
index 7d0dd30..81a727e 100644
--- a/windows/winpos.c
+++ b/windows/winpos.c
@@ -253,7 +253,7 @@
  *
  * Find the window and hittest for a given point.
  */
-INT16 WINPOS_WindowFromPoint( POINT16 pt, WND **ppWnd )
+INT16 WINPOS_WindowFromPoint( WND* wndScope, POINT16 pt, WND **ppWnd )
 {
     WND *wndPtr;
     INT16 hittest = HTERROR;
@@ -262,7 +262,7 @@
     *ppWnd = NULL;
     x = pt.x;
     y = pt.y;
-    wndPtr = WIN_GetDesktop()->child;
+    wndPtr = wndScope->child;
     for (;;)
     {
         while (wndPtr)
@@ -298,11 +298,20 @@
             else wndPtr = wndPtr->next;
         }
 
-        /* If nothing found, return the desktop window */
+        /* If nothing found, return the scope window */
         if (!*ppWnd)
         {
-            *ppWnd = WIN_GetDesktop();
-            return HTCLIENT;
+            *ppWnd = wndScope;
+            if( pt.x >= (wndScope->rectClient.left - wndScope->rectWindow.left) &&
+                pt.x >= (wndScope->rectClient.top - wndScope->rectWindow.top ) &&
+                pt.x <= (wndScope->rectClient.right - wndScope->rectWindow.left) &&
+                pt.x <= (wndScope->rectClient.bottom - wndScope->rectWindow.top ) )
+                return HTCLIENT;
+	    if( pt.x < 0 || pt.y < 0 || 
+		pt.x > (wndScope->rectWindow.right - wndScope->rectWindow.left) ||
+		pt.y > (wndScope->rectWindow.bottom - wndScope->rectWindow.top ) )
+		return HTNOWHERE;
+	    return HTCAPTION;	/* doesn't matter in this case */
         }
 
         /* Send the WM_NCHITTEST message (only if to the same task) */
@@ -331,7 +340,7 @@
 HWND16  WindowFromPoint16( POINT16 pt )
 {
     WND *pWnd;
-    WINPOS_WindowFromPoint( pt, &pWnd );
+    WINPOS_WindowFromPoint( WIN_GetDesktop(), pt, &pWnd );
     return pWnd->hwndSelf;
 }
 
@@ -344,7 +353,7 @@
     WND *pWnd;
     POINT16 pt16;
     CONV_POINT32TO16( &pt, &pt16 );
-    WINPOS_WindowFromPoint( pt16, &pWnd );
+    WINPOS_WindowFromPoint( WIN_GetDesktop(), pt16, &pWnd );
     return (HWND32)pWnd->hwndSelf;
 }
 
@@ -1419,9 +1428,12 @@
 
  if( uFlags & SMC_NOCOPY )	/* invalidate Wnd visible region */
    {
-     if (my != NULLREGION)  PAINT_RedrawWindow( Wnd->hwndSelf, NULL, newVisRgn, RDW_INVALIDATE |
-		            RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
-   } 
+     if (my != NULLREGION)
+	 PAINT_RedrawWindow( Wnd->hwndSelf, NULL, newVisRgn, RDW_INVALIDATE |
+	  RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
+     else if(uFlags & SMC_DRAWFRAME)
+	 Wnd->flags |= WIN_NEEDS_NCPAINT;
+   }
  else			/* bitblt old client area */
    { 
      HDC32 hDC;
@@ -1471,9 +1483,8 @@
                           DCX_KEEPCLIPRGN | DCX_INTERSECTRGN |
                           DCX_CACHE | DCX_CLIPSIBLINGS);
 
-         BitBlt( hDC, xto, yto, width, height, hDC, xfrom, yfrom, SRCCOPY );
-    
-	 ReleaseDC32( Wnd->parent->hwndSelf, hDC); 
+         BitBlt32( hDC, xto, yto, width, height, hDC, xfrom, yfrom, SRCCOPY );
+         ReleaseDC32( Wnd->parent->hwndSelf, hDC); 
        }
 
      if( update != NULLREGION )