Changeset 2403 for trunk/src


Ignore:
Timestamp:
Jan 11, 2000, 11:39:00 AM (26 years ago)
Author:
sandervl
Message:

LoadBitmap fix; split up win32wbase.cpp

Location:
trunk/src/user32/new
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/new/loadres.cpp

    r2400 r2403  
    1 /* $Id: loadres.cpp,v 1.15 2000-01-10 23:29:12 sandervl Exp $ */
     1/* $Id: loadres.cpp,v 1.16 2000-01-11 10:38:32 sandervl Exp $ */
    22
    33/*
    … …  
    252252        case OBM_OLD_LFARROW:
    253253        case OBM_CHECK:
     254        case OBM_RADIOCHECK:
    254255        case OBM_CHECKBOXES:
    255256        case OBM_BTNCORNERS:

  • trunk/src/user32/new/makefile

    r2396 r2403  
    1 # $Id: makefile,v 1.55 2000-01-10 17:18:07 cbratschi Exp $
     1# $Id: makefile,v 1.56 2000-01-11 10:38:33 sandervl Exp $
    22
    33#
    … …  
    4343        win32wbasepos.obj oslibres.obj dummy.obj dc.obj timer.obj \
    4444        caret.obj resource.obj winproc.obj text.obj oslibmsgtranslate.obj \
    45         windlgmsg.obj windlg.obj win32wdesktop.obj
     45        windlgmsg.obj windlg.obj win32wdesktop.obj win32wbasenonclient.obj
    4646
    4747
    … …  
    6969$(PDWIN32_LIB)/libuls.lib
    7070$(PDWIN32_LIB)/odincrt.lib
    71 $(PDWIN32_LIB)/shell32.lib
    7271OS2386.LIB
    7372$(RTLLIB_O)
    … …  
    133132win32class.obj: win32class.cpp win32class.h win32wbase.h win32dlg.h gen_object.h $(PDWIN32_INCLUDE)\heapshared.h oslibwin.h win32wndchild.h $(PDWIN32_INCLUDE)\win\winproc.h
    134133win32wbase.obj:   win32wbase.cpp win32class.h win32wbase.h win32dlg.h gen_object.h $(PDWIN32_INCLUDE)\heapshared.h oslibwin.h win32wndchild.h  $(PDWIN32_INCLUDE)\winres.h oslibres.h win32wndhandle.h oslibdos.h dc.h pmframe.h win32wdesktop.h controls.h winmouse.h $(PDWIN32_INCLUDE)\win\winproc.h $(PDWIN32_INCLUDE)\win\hook.h oslibmsg.h
     134win32wbasenonclient.obj:   win32wbasenonclient.cpp win32class.h win32wbase.h win32dlg.h gen_object.h $(PDWIN32_INCLUDE)\heapshared.h oslibwin.h win32wndchild.h  $(PDWIN32_INCLUDE)\winres.h oslibres.h win32wndhandle.h oslibdos.h dc.h controls.h oslibmsg.h pmframe.h
    135135win32wbasepos.obj: win32wbasepos.cpp win32class.h win32wbase.h win32dlg.h gen_object.h $(PDWIN32_INCLUDE)\heapshared.h oslibwin.h win32wndchild.h  $(PDWIN32_INCLUDE)\winres.h oslibres.h win32wndhandle.h oslibdos.h dc.h pmframe.h win32wdesktop.h
    136136win32wnd.obj:   win32wnd.cpp win32class.h win32wbase.h win32wnd.h win32dlg.h gen_object.h $(PDWIN32_INCLUDE)\heapshared.h oslibwin.h win32wndchild.h  $(PDWIN32_INCLUDE)\winres.h oslibres.h win32wndhandle.h oslibdos.h

  • trunk/src/user32/new/user32.cpp

    r2335 r2403  
    1 /* $Id: user32.cpp,v 1.24 2000-01-05 21:25:06 cbratschi Exp $ */
     1/* $Id: user32.cpp,v 1.25 2000-01-11 10:38:33 sandervl Exp $ */
    22
    33/*
    … …  
    851851        break;
    852852    }
    853     dprintf(("USER32:  GetSystemMetrics %d returned %d\n", nIndex, rc));
     853    dprintf2(("USER32:  GetSystemMetrics %d returned %d\n", nIndex, rc));
    854854    return(rc);
    855855}

  • trunk/src/user32/new/win32wbase.cpp

    r2401 r2403  
    1 /* $Id: win32wbase.cpp,v 1.30 2000-01-10 23:37:23 sandervl Exp $ */
     1/* $Id: win32wbase.cpp,v 1.31 2000-01-11 10:38:34 sandervl Exp $ */
    22/*
    33 * Win32 Window Base Class for OS/2
    44 *
    5  * Copyright 1998-1999 Sander van Leeuwen (sandervl@xs4all.nl)
     5 * Copyright 1998-2000 Sander van Leeuwen (sandervl@xs4all.nl)
    66 * Copyright 1999      Daniela Engert (dani@ngrt.de)
     7 * Copyright 2000      Christoph Bratschi (cbratschi@datacomm.ch)
    78 *
    89 * Parts based on Wine Windows code (windows\win.c)
    … …  
    4344#include "winmouse.h"
    4445#include <win\hook.h>
    45 #include <shellapi.h>
    4646#include <menu.h>
    4747#define INCL_TIMERWIN32
    … …  
    9292//For quick lookup of current process id
    9393static ULONG currentProcessId = -1;
    94 
    95 static HBITMAP hbitmapClose = 0;
    96 static HBITMAP hbitmapCloseD = 0;
    97 static HBITMAP hbitmapMinimize = 0;
    98 static HBITMAP hbitmapMinimizeD = 0;
    99 static HBITMAP hbitmapMaximize = 0;
    100 static HBITMAP hbitmapMaximizeD = 0;
    101 static HBITMAP hbitmapRestore = 0;
    102 static HBITMAP hbitmapRestoreD = 0;
    103 
    104 BYTE lpGrayMask[] = { 0xAA, 0xA0,
    105                       0x55, 0x50,
    106                       0xAA, 0xA0,
    107                       0x55, 0x50,
    108                       0xAA, 0xA0,
    109                       0x55, 0x50,
    110                       0xAA, 0xA0,
    111                       0x55, 0x50,
    112                       0xAA, 0xA0,
    113                       0x55, 0x50};
    11494
    11595//******************************************************************************
    … …  
    962942 BOOL  fClick = FALSE;
    963943
    964     dprintf(("MsgButton at (%d,%d)", msg->pt.x, msg->pt.y));
     944//    dprintf(("MsgButton at (%d,%d)", msg->pt.x, msg->pt.y));
    965945    switch(msg->message) {
    966946        case WM_LBUTTONDBLCLK:
    … …  
    12131193//******************************************************************************
    12141194//******************************************************************************
    1215 LONG Win32BaseWindow::HandleNCActivate(WPARAM wParam)
    1216 {
    1217   WORD wStateChange;
    1218 
    1219   if( wParam ) wStateChange = !(flags & WIN_NCACTIVATED);
    1220   else wStateChange = flags & WIN_NCACTIVATED;
    1221 
    1222   if( wStateChange )
    1223   {
    1224     if (wParam) flags |= WIN_NCACTIVATED;
    1225     else flags &= ~WIN_NCACTIVATED;
    1226 
    1227     if(!(dwStyle & WS_MINIMIZE))
    1228       DoNCPaint((HRGN)1,FALSE);
    1229   }
    1230 
    1231   return TRUE;
    1232 }
    1233 //******************************************************************************
    1234 //******************************************************************************
    1235 VOID Win32BaseWindow::TrackMinMaxBox(WORD wParam)
    1236 {
    1237   MSG msg;
    1238   HDC hdc;
    1239   BOOL pressed = TRUE;
    1240   UINT state;
    1241 
    1242   if (wParam == HTMINBUTTON)
    1243   {
    1244     /* If the style is not present, do nothing */
    1245     if (!(dwStyle & WS_MINIMIZEBOX))
    1246       return;
    1247     /* Check if the sysmenu item for minimize is there  */
    1248     state = GetMenuState(hSysMenu,SC_MINIMIZE,MF_BYCOMMAND);
    1249   } else
    1250   {
    1251     /* If the style is not present, do nothing */
    1252     if (!(dwStyle & WS_MAXIMIZEBOX))
    1253       return;
    1254     /* Check if the sysmenu item for maximize is there  */
    1255     state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
    1256   }
    1257   SetCapture(Win32Hwnd);
    1258   hdc = GetWindowDC(Win32Hwnd);
    1259   if (wParam == HTMINBUTTON)
    1260     DrawMinButton(hdc,TRUE,FALSE);
    1261   else
    1262     DrawMaxButton(hdc,TRUE,FALSE);
    1263   do
    1264   {
    1265     BOOL oldstate = pressed;
    1266 
    1267     GetMessageA(&msg,Win32Hwnd,0,0);
    1268     pressed = (HandleNCHitTest(msg.pt) == wParam);
    1269     if (pressed != oldstate)
    1270     {
    1271       if (wParam == HTMINBUTTON)
    1272         DrawMinButton(hdc,pressed,FALSE);
    1273       else
    1274         DrawMaxButton(hdc,pressed,FALSE);
    1275     }
    1276   } while (msg.message != WM_LBUTTONUP);
    1277   if (wParam == HTMINBUTTON)
    1278     DrawMinButton(hdc,FALSE,FALSE);
    1279   else
    1280     DrawMaxButton(hdc,FALSE,FALSE);
    1281   ReleaseCapture();
    1282   ReleaseDC(Win32Hwnd,hdc);
    1283   /* If the item minimize or maximize of the sysmenu are not there */
    1284   /* or if the style is not present, do nothing */
    1285   if ((!pressed) || (state == 0xFFFFFFFF))
    1286     return;
    1287   if (wParam == HTMINBUTTON)
    1288     SendInternalMessageA(WM_SYSCOMMAND,SC_MINIMIZE,*(LPARAM*)&msg.pt);
    1289   else
    1290     SendInternalMessageA(WM_SYSCOMMAND,IsZoomed(Win32Hwnd) ? SC_RESTORE:SC_MAXIMIZE,*(LPARAM*)&msg.pt);
    1291 }
    1292 //******************************************************************************
    1293 //******************************************************************************
    1294 VOID Win32BaseWindow::TrackCloseButton(WORD wParam)
    1295 {
    1296   MSG msg;
    1297   HDC hdc;
    1298   BOOL pressed = TRUE;
    1299   UINT state;
    1300 
    1301   if (hSysMenu == 0)
    1302     return;
    1303   state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
    1304   /* If the item close of the sysmenu is disabled or not there do nothing */
    1305   if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
    1306     return;
    1307   hdc = GetWindowDC(Win32Hwnd);
    1308   SetCapture(Win32Hwnd);
    1309   DrawCloseButton(hdc,TRUE,FALSE);
    1310   do
    1311   {
    1312     BOOL oldstate = pressed;
    1313 
    1314     GetMessageA(&msg,Win32Hwnd,0,0);
    1315     pressed = (HandleNCHitTest(msg.pt) == wParam);
    1316     if (pressed != oldstate)
    1317       DrawCloseButton(hdc, pressed, FALSE);
    1318   } while (msg.message != WM_LBUTTONUP);
    1319   DrawCloseButton(hdc,FALSE,FALSE);
    1320   ReleaseCapture();
    1321   ReleaseDC(Win32Hwnd,hdc);
    1322   if (!pressed) return;
    1323   SendInternalMessageA(WM_SYSCOMMAND,SC_CLOSE,*(LPARAM*)&msg.pt);
    1324 }
    1325 //******************************************************************************
    1326 //******************************************************************************
    1327 VOID Win32BaseWindow::TrackScrollBar(WPARAM wParam,POINT pt)
    1328 {
    1329   INT scrollbar;
    1330   MSG msg;
    1331 
    1332   if ((wParam & 0xfff0) == SC_HSCROLL)
    1333   {
    1334     if ((wParam & 0x0f) != HTHSCROLL) return;
    1335     scrollbar = SB_HORZ;
    1336   } else  /* SC_VSCROLL */
    1337   {
    1338     if ((wParam & 0x0f) != HTVSCROLL) return;
    1339     scrollbar = SB_VERT;
    1340   }
    1341 
    1342   pt.x -= rectWindow.left;
    1343   pt.y -= rectWindow.top;
    1344   SCROLL_HandleScrollEvent(Win32Hwnd,0,MAKELONG(pt.x,pt.y),scrollbar,WM_LBUTTONDOWN);
    1345   if (GetCapture() != Win32Hwnd) return;
    1346   do
    1347   {
    1348     GetMessageA(&msg,Win32Hwnd,0,0);
    1349     switch(msg.message)
    1350     {
    1351       case WM_LBUTTONUP:
    1352       case WM_MOUSEMOVE:
    1353         pt.x = msg.pt.x-rectWindow.left;
    1354         pt.y = msg.pt.y-rectWindow.top;
    1355         msg.lParam = MAKELONG(pt.x,pt.y);
    1356       case WM_SYSTIMER:
    1357         SCROLL_HandleScrollEvent(Win32Hwnd,msg.wParam,msg.lParam,scrollbar,msg.message);
    1358         break;
    1359 
    1360       default:
    1361         TranslateMessage(&msg);
    1362         DispatchMessageA(&msg);
    1363         break;
    1364     }
    1365     if (!IsWindow())
    1366     {
    1367       ReleaseCapture();
    1368       break;
    1369     }
    1370   } while (msg.message != WM_LBUTTONUP);
    1371 }
    1372 //******************************************************************************
    1373 //******************************************************************************
    1374 LONG Win32BaseWindow::HandleNCLButtonDown(WPARAM wParam,LPARAM lParam)
    1375 {
    1376   switch(wParam)  /* Hit test */
    1377   {
    1378     case HTCAPTION:
    1379       SetActiveWindow();
    1380       if (GetActiveWindow() == Win32Hwnd)
    1381         SendInternalMessageA(WM_SYSCOMMAND,SC_MOVE+HTCAPTION,lParam);
    1382       break;
    1383 
    1384     case HTSYSMENU:
    1385       if(dwStyle & WS_SYSMENU )
    1386       {
    1387         if( !(dwStyle & WS_MINIMIZE) )
    1388         {
    1389           HDC hDC = GetWindowDC(Win32Hwnd);
    1390           DrawSysButton(hDC,TRUE);
    1391           ReleaseDC(Win32Hwnd,hDC);
    1392         }
    1393         SendInternalMessageA(WM_SYSCOMMAND,SC_MOUSEMENU+HTSYSMENU,lParam);
    1394       }
    1395       break;
    1396 
    1397     case HTMENU:
    1398       SendInternalMessageA(WM_SYSCOMMAND,SC_MOUSEMENU,lParam);
    1399       break;
    1400 
    1401     case HTHSCROLL:
    1402       SendInternalMessageA(WM_SYSCOMMAND,SC_HSCROLL+HTHSCROLL,lParam);
    1403       break;
    1404 
    1405     case HTVSCROLL:
    1406       SendInternalMessageA(WM_SYSCOMMAND,SC_VSCROLL+HTVSCROLL,lParam);
    1407       break;
    1408 
    1409     case HTMINBUTTON:
    1410     case HTMAXBUTTON:
    1411       TrackMinMaxBox(wParam);
    1412       break;
    1413 
    1414     case HTCLOSE:
    1415       TrackCloseButton(wParam);
    1416       break;
    1417 
    1418     case HTLEFT:
    1419     case HTRIGHT:
    1420     case HTTOP:
    1421     case HTTOPLEFT:
    1422     case HTTOPRIGHT:
    1423     case HTBOTTOM:
    1424     case HTBOTTOMLEFT:
    1425     case HTBOTTOMRIGHT:
    1426         /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
    1427         SendInternalMessageA(WM_SYSCOMMAND,SC_SIZE+wParam-2,lParam);
    1428         break;
    1429     case HTBORDER:
    1430         break;
    1431   }
    1432 
    1433   return 0;
    1434 }
    1435 //******************************************************************************
    1436 //******************************************************************************
    1437 BOOL Win32BaseWindow::WindowNeedsWMBorder()
    1438 {
    1439   if (!(dwStyle & WS_CHILD) &&
    1440       //Options.managed  && //CB: to check
    1441       !(dwExStyle & WS_EX_TOOLWINDOW) &&
    1442       ( ((dwStyle & WS_CAPTION) == WS_CAPTION) ||
    1443         (dwStyle & WS_THICKFRAME)))
    1444       return TRUE;
    1445   if (dwExStyle & WS_EX_TRAYWINDOW)
    1446     return TRUE;
    1447   return FALSE;
    1448 }
    1449 //******************************************************************************
    1450 //******************************************************************************
    1451 VOID Win32BaseWindow::AdjustRectOuter(LPRECT rect,BOOL menu)
    1452 {
    1453   if(dwStyle & WS_ICONIC) return;
    1454 
    1455   /* Decide if the window will be managed (see CreateWindowEx) */
    1456   //if (!WindowNeedsWMBorder()) //CB: check Options.managed
    1457   {
    1458     if (HAS_THICKFRAME(dwStyle,dwExStyle ))
    1459       InflateRect( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
    1460     else
    1461       if (HAS_DLGFRAME( dwStyle, dwExStyle ))
    1462         InflateRect(rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
    1463       else
    1464         if (HAS_THINFRAME( dwStyle ))
    1465           InflateRect( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
    1466 
    1467     if ((dwStyle & WS_CAPTION) == WS_CAPTION)
    1468     {
    1469       if (dwExStyle & WS_EX_TOOLWINDOW)
    1470         rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
    1471       else
    1472         rect->top -= GetSystemMetrics(SM_CYCAPTION);
    1473     }
    1474   }
    1475 
    1476   if (menu)
    1477     rect->top -= GetSystemMetrics(SM_CYMENU);
    1478 }
    1479 //******************************************************************************
    1480 //******************************************************************************
    1481 VOID Win32BaseWindow::AdjustRectInner(LPRECT rect)
    1482 {
    1483   if(dwStyle & WS_ICONIC) return;
    1484 
    1485   if (dwExStyle & WS_EX_CLIENTEDGE)
    1486     InflateRect (rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
    1487 
    1488   if (dwExStyle & WS_EX_STATICEDGE)
    1489     InflateRect (rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
    1490 
    1491   if (dwStyle & WS_VSCROLL) rect->right  += GetSystemMetrics(SM_CXVSCROLL);
    1492   if (dwStyle & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
    1493 }
    1494 //******************************************************************************
    1495 //******************************************************************************
    1496 LONG Win32BaseWindow::HandleNCCalcSize(BOOL calcValidRects,RECT *winRect)
    1497 {
    1498   RECT tmpRect = { 0, 0, 0, 0 },*clientRect;
    1499   LONG result = WVR_ALIGNTOP | WVR_ALIGNLEFT;
    1500   UINT style;
    1501 
    1502   if (!calcValidRects) return 0;
    1503 
    1504   style = (UINT) GetClassLongA(Win32Hwnd,GCL_STYLE);
    1505 
    1506   if (style & CS_VREDRAW) result |= WVR_VREDRAW;
    1507   if (style & CS_HREDRAW) result |= WVR_HREDRAW;
    1508 
    1509   clientRect = &((NCCALCSIZE_PARAMS*)winRect)->rgrc[2];
    1510   *clientRect = rectWindow;
    1511   if (getParent()) mapWin32Rect(OSLIB_HWND_DESKTOP,getParent()->getOS2WindowHandle(),clientRect);
    1512 
    1513   if(!(dwStyle & WS_MINIMIZE))
    1514   {
    1515     AdjustRectOuter(&tmpRect,FALSE);
    1516 
    1517     clientRect->left   -= tmpRect.left;
    1518     clientRect->top    -= tmpRect.top;
    1519     clientRect->right  -= tmpRect.right;
    1520     clientRect->bottom -= tmpRect.bottom;
    1521 
    1522     if (HAS_MENU())
    1523     {
    1524       clientRect->top +=
    1525                 MENU_GetMenuBarHeight(Win32Hwnd,
    1526                                        winRect->right - winRect->left,
    1527                                        -tmpRect.left, -tmpRect.top ) + 1;
    1528     }
    1529 
    1530     SetRect (&tmpRect, 0, 0, 0, 0);
    1531     AdjustRectInner(&tmpRect);
    1532     clientRect->left   -= tmpRect.left;
    1533     clientRect->top    -= tmpRect.top;
    1534     clientRect->right  -= tmpRect.right;
    1535     clientRect->bottom -= tmpRect.bottom;
    1536   }
    1537 
    1538   return result;
    1539 }
    1540 //******************************************************************************
    1541 //******************************************************************************
    1542 LONG Win32BaseWindow::HandleNCHitTest(POINT pt)
    1543 {
    1544   RECT rect = rectWindow;
    1545 
    1546   if (!PtInRect(&rect,pt)) return HTNOWHERE;
    1547 
    1548   if (dwStyle & WS_MINIMIZE) return HTCAPTION;
    1549 
    1550   if (!(flags & WIN_MANAGED))
    1551   {
    1552     /* Check borders */
    1553     if (HAS_THICKFRAME(dwStyle,dwExStyle))
    1554     {
    1555       InflateRect(&rect,-GetSystemMetrics(SM_CXFRAME),-GetSystemMetrics(SM_CYFRAME));
    1556       if (!PtInRect(&rect,pt))
    1557       {
    1558         /* Check top sizing border */
    1559         if (pt.y < rect.top)
    1560         {
    1561           if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
    1562           if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
    1563           return HTTOP;
    1564         }
    1565         /* Check bottom sizing border */
    1566         if (pt.y >= rect.bottom)
    1567         {
    1568           if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
    1569           if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
    1570           return HTBOTTOM;
    1571         }
    1572         /* Check left sizing border */
    1573         if (pt.x < rect.left)
    1574         {
    1575           if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
    1576           if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
    1577           return HTLEFT;
    1578         }
    1579         /* Check right sizing border */
    1580         if (pt.x >= rect.right)
    1581         {
    1582           if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
    1583           if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
    1584           return HTRIGHT;
    1585         }
    1586       }
    1587     } else  /* No thick frame */
    1588     {
    1589       if (HAS_DLGFRAME(dwStyle,dwExStyle))
    1590         InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
    1591       else if (HAS_THINFRAME(dwStyle ))
    1592         InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
    1593       if (!PtInRect( &rect, pt )) return HTBORDER;
    1594     }
    1595 
    1596     /* Check caption */
    1597 
    1598     if ((dwStyle & WS_CAPTION) == WS_CAPTION)
    1599     {
    1600       if (dwExStyle & WS_EX_TOOLWINDOW)
    1601         rect.top += GetSystemMetrics(SM_CYSMCAPTION)-1;
    1602       else
    1603         rect.top += GetSystemMetrics(SM_CYCAPTION)-1;
    1604       if (!PtInRect(&rect,pt))
    1605       {
    1606         /* Check system menu */
    1607         if(dwStyle & WS_SYSMENU)
    1608         {
    1609           /* Check if there is an user icon */
    1610           HICON hIcon = (HICON) GetClassLongA(Win32Hwnd, GCL_HICONSM);
    1611           if(!hIcon) hIcon = (HICON) GetClassLongA(Win32Hwnd, GCL_HICON);
    1612 
    1613           /* If there is an icon associated with the window OR              */
    1614           /* If there is no hIcon specified and this is not a modal dialog, */
    1615           /* there is a system menu icon.                                   */
    1616           if((hIcon != 0) || (!(dwStyle & DS_MODALFRAME)))
    1617           rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
    1618         }
    1619         if (pt.x < rect.left) return HTSYSMENU;
    1620 
    1621         /* Check close button */
    1622         if (dwStyle & WS_SYSMENU)
    1623         rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
    1624         if (pt.x > rect.right) return HTCLOSE;
    1625 
    1626         /* Check maximize box */
    1627         /* In win95 there is automatically a Maximize button when there is a minimize one*/
    1628         if ((dwStyle & WS_MAXIMIZEBOX)|| (dwStyle & WS_MINIMIZEBOX))
    1629         rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
    1630         if (pt.x > rect.right) return HTMAXBUTTON;
    1631 
    1632         /* Check minimize box */
    1633         /* In win95 there is automatically a Maximize button when there is a Maximize one*/
    1634         if ((dwStyle & WS_MINIMIZEBOX)||(dwStyle & WS_MAXIMIZEBOX))
    1635         rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
    1636 
    1637         if (pt.x > rect.right) return HTMINBUTTON;
    1638         return HTCAPTION;
    1639       }
    1640     }
    1641   }
    1642 
    1643   /* Check client area */
    1644 
    1645   ScreenToClient(Win32Hwnd,&pt);
    1646   getClientRect(&rect);
    1647   if (PtInRect(&rect,pt)) return HTCLIENT;
    1648 
    1649   /* Check vertical scroll bar */
    1650 
    1651   if (dwStyle & WS_VSCROLL)
    1652   {
    1653     rect.right += GetSystemMetrics(SM_CXVSCROLL);
    1654     if (PtInRect( &rect, pt )) return HTVSCROLL;
    1655   }
    1656 
    1657   /* Check horizontal scroll bar */
    1658 
    1659   if (dwStyle & WS_HSCROLL)
    1660   {
    1661     rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
    1662     if (PtInRect( &rect, pt ))
    1663     {
    1664       /* Check size box */
    1665       if ((dwStyle & WS_VSCROLL) &&
    1666           (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
    1667         return (dwStyle & WS_CHILD) ? HTSIZE:HTBOTTOMRIGHT;
    1668       return HTHSCROLL;
    1669     }
    1670   }
    1671 
    1672   /* Check menu bar */
    1673 
    1674   if (HAS_MENU())
    1675   {
    1676     if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
    1677       return HTMENU;
    1678   }
    1679 
    1680   /* Should never get here */
    1681   return HTERROR;
    1682 }
    1683 
    1684 //******************************************************************************
    1685 //******************************************************************************
    1686 VOID Win32BaseWindow::GetInsideRect(RECT *rect)
    1687 {
    1688   rect->top    = rect->left = 0;
    1689   rect->right  = rectWindow.right - rectWindow.left;
    1690   rect->bottom = rectWindow.bottom - rectWindow.top;
    1691 
    1692   if ((dwStyle & WS_ICONIC) || (flags & WIN_MANAGED)) return;
    1693 
    1694   /* Remove frame from rectangle */
    1695   if (HAS_THICKFRAME(dwStyle,dwExStyle))
    1696   {
    1697     InflateRect( rect, -GetSystemMetrics(SM_CXSIZEFRAME), -GetSystemMetrics(SM_CYSIZEFRAME) );
    1698   }
    1699   else if (HAS_DLGFRAME(dwStyle,dwExStyle ))
    1700   {
    1701     InflateRect( rect, -GetSystemMetrics(SM_CXFIXEDFRAME), -GetSystemMetrics(SM_CYFIXEDFRAME));
    1702   }
    1703   else if (HAS_THINFRAME(dwStyle))
    1704   {
    1705     InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
    1706   }
    1707 
    1708   /* We have additional border information if the window
    1709    * is a child (but not an MDI child) */
    1710   if ( (dwStyle & WS_CHILD)  &&
    1711        ( (dwExStyle & WS_EX_MDICHILD) == 0 ) )
    1712   {
    1713     if (dwExStyle & WS_EX_CLIENTEDGE)
    1714       InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
    1715 
    1716     if (dwExStyle & WS_EX_STATICEDGE)
    1717       InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
    1718   }
    1719 }
    1720 //******************************************************************************
    1721 //******************************************************************************
    1722 VOID Win32BaseWindow::DrawFrame(HDC hdc,RECT *rect,BOOL dlgFrame,BOOL active)
    1723 {
    1724   INT width, height;
    1725   HBRUSH oldBrush;
    1726 
    1727   if (dlgFrame)
    1728   {
    1729     width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
    1730     height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
    1731   } else
    1732   {
    1733     width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXEDGE);
    1734     height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYEDGE);
    1735   }
    1736 
    1737   oldBrush = SelectObject(hdc,GetSysColorBrush(active ? COLOR_ACTIVEBORDER:COLOR_INACTIVEBORDER));
    1738 
    1739   /* Draw frame */
    1740 
    1741   PatBlt(hdc,rect->left,rect->top,rect->right-rect->left,height,PATCOPY);
    1742   PatBlt(hdc,rect->left,rect->top,width,rect->bottom-rect->top,PATCOPY);
    1743   PatBlt(hdc,rect->left,rect->bottom-1,rect->right-rect->left,-height,PATCOPY);
    1744   PatBlt(hdc,rect->right-1,rect->top,-width,rect->bottom-rect->top,PATCOPY);
    1745   SelectObject(hdc,oldBrush);
    1746 
    1747   InflateRect(rect,-width,-height);
    1748 }
    1749 //******************************************************************************
    1750 //******************************************************************************
    1751 BOOL Win32BaseWindow::DrawSysButton(HDC hdc,BOOL down)
    1752 {
    1753   if(!(flags & WIN_MANAGED))
    1754   {
    1755     HICON  hIcon;
    1756     RECT rect;
    1757 
    1758     GetInsideRect(&rect);
    1759 
    1760     hIcon = (HICON) GetClassLongA(Win32Hwnd, GCL_HICONSM);
    1761     if(!hIcon) hIcon = (HICON) GetClassLongA(Win32Hwnd, GCL_HICON);
    1762 
    1763     /* If there is no hIcon specified or this is not a modal dialog, */
    1764     /* get the default one.                                          */
    1765     if(hIcon == 0)
    1766       if (!(dwStyle & DS_MODALFRAME))
    1767         hIcon = LoadImageA(0, MAKEINTRESOURCEA(OIC_ODINICON), IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
    1768 
    1769     if (hIcon)
    1770       DrawIconEx (hdc, rect.left + 2, rect.top + 2, hIcon,
    1771                   GetSystemMetrics(SM_CXSMICON),
    1772                   GetSystemMetrics(SM_CYSMICON),
    1773                   0, 0, DI_NORMAL);
    1774 
    1775     return (hIcon != 0);
    1776   }
    1777   return FALSE;
    1778 }
    1779 //******************************************************************************
    1780 //******************************************************************************
    1781 BOOL Win32BaseWindow::GetSysPopupPos(RECT* rect)
    1782 {
    1783   if(hSysMenu)
    1784   {
    1785       if(dwStyle & WS_MINIMIZE )
    1786         *rect = rectWindow;
    1787       else
    1788       {
    1789           GetInsideRect(rect );
    1790           OffsetRect( rect, rectWindow.left, rectWindow.top);
    1791           if ((dwStyle & WS_CHILD) && getParent())
    1792               ClientToScreen(getParent()->getWindowHandle(), (POINT *)rect );
    1793           rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
    1794           rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
    1795       }
    1796       return TRUE;
    1797   }
    1798   return FALSE;
    1799 }
    1800 //******************************************************************************
    1801 //******************************************************************************
    1802 BOOL Win32BaseWindow::DrawGrayButton(HDC hdc,int x,int y)
    1803 {
    1804   HBITMAP hMaskBmp;
    1805   HDC hdcMask = CreateCompatibleDC (0);
    1806   HBRUSH hOldBrush;
    1807   hMaskBmp = CreateBitmap (12, 10, 1, 1, lpGrayMask);
    1808 
    1809   if(hMaskBmp == 0)
    1810     return FALSE;
    1811 
    1812   SelectObject (hdcMask, hMaskBmp);
    1813 
    1814   /* Draw the grayed bitmap using the mask */
    1815   hOldBrush = SelectObject (hdc, RGB(128, 128, 128));
    1816   BitBlt (hdc, x, y, 12, 10,
    1817           hdcMask, 0, 0, 0xB8074A);
    1818 
    1819   /* Clean up */
    1820   SelectObject (hdc, hOldBrush);
    1821   DeleteObject(hMaskBmp);
    1822   DeleteDC (hdcMask);
    1823 
    1824   return TRUE;
    1825 }
    1826 //******************************************************************************
    1827 //******************************************************************************
    1828 VOID Win32BaseWindow::DrawCloseButton(HDC hdc,BOOL down,BOOL bGrayed)
    1829 {
    1830   RECT rect;
    1831   HDC hdcMem;
    1832 
    1833   if( !(flags & WIN_MANAGED) )
    1834   {
    1835     BITMAP bmp;
    1836     HBITMAP hBmp, hOldBmp;
    1837 
    1838     GetInsideRect(&rect);
    1839 
    1840     hdcMem = CreateCompatibleDC( hdc );
    1841     hBmp = down ? hbitmapCloseD : hbitmapClose;
    1842     hOldBmp = SelectObject (hdcMem, hBmp);
    1843     GetObjectA (hBmp, sizeof(BITMAP), &bmp);
    1844 
    1845     BitBlt (hdc, rect.right - (GetSystemMetrics(SM_CYCAPTION) + 1 + bmp.bmWidth) / 2,
    1846             rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
    1847             bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY);
    1848 
    1849     if(bGrayed)
    1850       DrawGrayButton(hdc,rect.right - (GetSystemMetrics(SM_CYCAPTION) + 1 + bmp.bmWidth) / 2 + 2,
    1851                      rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
    1852 
    1853     SelectObject (hdcMem, hOldBmp);
    1854     DeleteDC (hdcMem);
    1855   }
    1856 }
    1857 //******************************************************************************
    1858 //******************************************************************************
    1859 VOID Win32BaseWindow::DrawMaxButton(HDC hdc,BOOL down,BOOL bGrayed)
    1860 {
    1861   RECT rect;
    1862   HDC hdcMem;
    1863 
    1864   if( !(flags & WIN_MANAGED))
    1865   {
    1866     BITMAP  bmp;
    1867     HBITMAP  hBmp,hOldBmp;
    1868 
    1869     GetInsideRect(&rect);
    1870     hdcMem = CreateCompatibleDC( hdc );
    1871     hBmp = IsZoomed(Win32Hwnd) ?
    1872             (down ? hbitmapRestoreD : hbitmapRestore ) :
    1873             (down ? hbitmapMaximizeD: hbitmapMaximize);
    1874     hOldBmp=SelectObject( hdcMem, hBmp );
    1875     GetObjectA (hBmp, sizeof(BITMAP), &bmp);
    1876 
    1877     if (dwStyle & WS_SYSMENU)
    1878       rect.right -= GetSystemMetrics(SM_CYCAPTION) + 1;
    1879 
    1880     BitBlt( hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2,
    1881           rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
    1882           bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY );
    1883 
    1884     if(bGrayed)
    1885       DrawGrayButton(hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2 + 2,
    1886                       rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
    1887 
    1888 
    1889     SelectObject (hdcMem, hOldBmp);
    1890     DeleteDC( hdcMem );
    1891   }
    1892 }
    1893 //******************************************************************************
    1894 //******************************************************************************
    1895 VOID Win32BaseWindow::DrawMinButton(HDC hdc,BOOL down,BOOL bGrayed)
    1896 {
    1897   RECT rect;
    1898   HDC hdcMem;
    1899 
    1900   if( !(flags & WIN_MANAGED))
    1901 
    1902   {
    1903     BITMAP  bmp;
    1904     HBITMAP  hBmp,hOldBmp;
    1905 
    1906     GetInsideRect(&rect);
    1907 
    1908     hdcMem = CreateCompatibleDC( hdc );
    1909     hBmp = down ? hbitmapMinimizeD : hbitmapMinimize;
    1910     hOldBmp= SelectObject( hdcMem, hBmp );
    1911     GetObjectA (hBmp, sizeof(BITMAP), &bmp);
    1912 
    1913     if (dwStyle & WS_SYSMENU)
    1914       rect.right -= GetSystemMetrics(SM_CYCAPTION) + 1;
    1915 
    1916     /* In win 95 there is always a Maximize box when there is a Minimize one */
    1917     if ((dwStyle & WS_MAXIMIZEBOX) || (dwStyle & WS_MINIMIZEBOX))
    1918       rect.right += -1 - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2;
    1919 
    1920     BitBlt( hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2,
    1921           rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
    1922           bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY );
    1923 
    1924     if(bGrayed)
    1925       DrawGrayButton(hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2 + 2,
    1926                       rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
    1927 
    1928 
    1929     SelectObject (hdcMem, hOldBmp);
    1930     DeleteDC( hdcMem );
    1931   }
    1932 }
    1933 //******************************************************************************
    1934 //******************************************************************************
    1935 VOID Win32BaseWindow::DrawCaption(HDC hdc,RECT *rect,BOOL active)
    1936 {
    1937   RECT  r = *rect;
    1938   char  buffer[256];
    1939   HPEN  hPrevPen;
    1940 
    1941   if (flags & WIN_MANAGED) return;
    1942 
    1943   hPrevPen = SelectObject( hdc, GetSysColorPen(COLOR_3DFACE) );
    1944   MoveToEx( hdc, r.left, r.bottom - 1, NULL );
    1945   LineTo( hdc, r.right, r.bottom - 1 );
    1946   SelectObject( hdc, hPrevPen );
    1947   r.bottom--;
    1948 
    1949   if (SYSCOLOR_GetUseWinColors())
    1950   {
    1951     COLORREF startColor = GetSysColor(active ? COLOR_ACTIVECAPTION:COLOR_INACTIVECAPTION),endColor = GetSysColor(active ? COLOR_GRADIENTACTIVECAPTION:COLOR_GRADIENTINACTIVECAPTION);
    1952 
    1953     if (startColor == endColor)
    1954       FillRect(hdc,&r,GetSysColorBrush(startColor));
    1955     else
    1956     {
    1957       INT rDiff = GetRValue(endColor)-GetRValue(startColor);
    1958       INT gDiff = GetGValue(endColor)-GetGValue(startColor);
    1959       INT bDiff = GetBValue(endColor)-GetBValue(startColor);
    1960       INT steps = MAX(MAX(abs(rDiff),abs(gDiff)),abs(bDiff));
    1961       INT w = r.right-r.left;
    1962       RECT r2;
    1963 
    1964       if (w < steps) steps = w;
    1965       r2.left = r2.right = r.left;
    1966       r2.top = r.top;
    1967       r2.bottom = r.bottom;
    1968       for (INT x = 0;x <= steps;x++)
    1969       {
    1970         COLORREF color = RGB(GetRValue(startColor)+rDiff*x/steps,GetGValue(startColor)+gDiff*x/steps,GetBValue(startColor)+bDiff*x/steps);
    1971         HBRUSH brush = CreateSolidBrush(color);
    1972 
    1973         r2.left = r2.right;
    1974         r2.right = r.left+w*x/steps;
    1975         FillRect(hdc,&r2,brush);
    1976         DeleteObject(brush);
    1977       }
    1978     }
    1979   } else FillRect(hdc,&r,GetSysColorBrush(active ? COLOR_ACTIVECAPTION:COLOR_INACTIVECAPTION));
    1980 
    1981   if (!hbitmapClose)
    1982   {
    1983     if (!(hbitmapClose = LoadBitmapA(0,MAKEINTRESOURCEA(OBM_CLOSE)))) return;
    1984     hbitmapCloseD    = LoadBitmapA(0,MAKEINTRESOURCEA(OBM_CLOSED));
    1985     hbitmapMinimize  = LoadBitmapA(0,MAKEINTRESOURCEA(OBM_REDUCE));
    1986     hbitmapMinimizeD = LoadBitmapA(0,MAKEINTRESOURCEA(OBM_REDUCED));
    1987     hbitmapMaximize  = LoadBitmapA(0,MAKEINTRESOURCEA(OBM_ZOOM));
    1988     hbitmapMaximizeD = LoadBitmapA(0,MAKEINTRESOURCEA(OBM_ZOOMD));
    1989     hbitmapRestore   = LoadBitmapA(0,MAKEINTRESOURCEA(OBM_RESTORE));
    1990     hbitmapRestoreD  = LoadBitmapA(0,MAKEINTRESOURCEA(OBM_RESTORED));
    1991   }
    1992 
    1993   if ((dwStyle & WS_SYSMENU) && !(dwExStyle & WS_EX_TOOLWINDOW))
    1994   {
    1995     if (DrawSysButton(hdc,FALSE))
    1996       r.left += GetSystemMetrics(SM_CYCAPTION) - 1;
    1997   }
    1998 
    1999   if (dwStyle & WS_SYSMENU)
    2000   {
    2001     UINT state;
    2002 
    2003     /* Go get the sysmenu */
    2004     state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
    2005 
    2006     /* Draw a grayed close button if disabled and a normal one if SC_CLOSE is not there */
    2007     DrawCloseButton(hdc, FALSE,
    2008                     ((((state & MF_DISABLED) || (state & MF_GRAYED))) && (state != 0xFFFFFFFF)));
    2009     r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
    2010 
    2011     if ((dwStyle & WS_MAXIMIZEBOX) || (dwStyle & WS_MINIMIZEBOX))
    2012     {
    2013       /* In win95 the two buttons are always there */
    2014       /* But if the menu item is not in the menu they're disabled*/
    2015 
    2016       DrawMaxButton(hdc, FALSE, (!(dwStyle & WS_MAXIMIZEBOX)));
    2017       r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
    2018 
    2019       DrawMinButton(hdc, FALSE,  (!(dwStyle & WS_MINIMIZEBOX)));
    2020             r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
    2021     }
    2022   }
    2023 
    2024   if (GetWindowTextA(buffer, sizeof(buffer) ))
    2025   {
    2026     NONCLIENTMETRICSA nclm;
    2027     HFONT hFont, hOldFont;
    2028     nclm.cbSize = sizeof(NONCLIENTMETRICSA);
    2029     SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
    2030     if (dwExStyle & WS_EX_TOOLWINDOW)
    2031       hFont = CreateFontIndirectA (&nclm.lfSmCaptionFont);
    2032     else
    2033       hFont = CreateFontIndirectA (&nclm.lfCaptionFont);
    2034     hOldFont = SelectObject (hdc, hFont);
    2035     if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
    2036     else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
    2037     SetBkMode( hdc, TRANSPARENT );
    2038     r.left += 2;
    2039     DrawTextA( hdc, buffer, -1, &r,
    2040              DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
    2041     DeleteObject (SelectObject (hdc, hOldFont));
    2042   }
    2043 }
    2044 //******************************************************************************
    2045 //******************************************************************************
    2046 VOID Win32BaseWindow::DoNCPaint(HRGN clip,BOOL suppress_menupaint)
    2047 {
    2048   BOOL active  = flags & WIN_NCACTIVATED;
    2049   HDC hdc;
    2050   RECT rect,rectClip,rfuzz;
    2051 
    2052   /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
    2053      the call to GetDCEx implying that it is allowed not to use it either.
    2054      However, the suggested GetDCEx(    , DCX_WINDOW | DCX_INTERSECTRGN)
    2055      will cause clipRgn to be deleted after ReleaseDC().
    2056      Now, how is the "system" supposed to tell what happened?
    2057    */
    2058 
    2059   if (!(hdc = GetDCEx( Win32Hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
    2060                       ((clip > 1) ?(DCX_INTERSECTRGN /*| DCX_KEEPCLIPRGN*/) : 0) ))) return;
    2061 
    2062   rect.top = rect.left = 0;
    2063   rect.right  = rectWindow.right - rectWindow.left;
    2064   rect.bottom = rectWindow.bottom - rectWindow.top;
    2065 
    2066   if( clip > 1 )
    2067     GetRgnBox( clip, &rectClip );
    2068   else
    2069   {
    2070     clip = 0;
    2071     rectClip = rect;
    2072   }
    2073 
    2074   SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
    2075 
    2076   if(!(flags & WIN_MANAGED))
    2077   {
    2078     if (HAS_BIGFRAME( dwStyle, dwExStyle))
    2079     {
    2080       DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
    2081     }
    2082     if (HAS_THICKFRAME( dwStyle, dwExStyle ))
    2083       DrawFrame(hdc, &rect, FALSE, active );
    2084     else if (HAS_DLGFRAME( dwStyle, dwExStyle ))
    2085       DrawFrame( hdc, &rect, TRUE, active );
    2086     else if (HAS_THINFRAME( dwStyle ))
    2087     {
    2088       SelectObject( hdc, GetStockObject(NULL_BRUSH) );
    2089       Rectangle( hdc, 0, 0, rect.right, rect.bottom );
    2090     }
    2091 
    2092     if ((dwStyle & WS_CAPTION) == WS_CAPTION)
    2093     {
    2094       RECT  r = rect;
    2095       if (dwExStyle & WS_EX_TOOLWINDOW)
    2096       {
    2097         r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
    2098         rect.top += GetSystemMetrics(SM_CYSMCAPTION);
    2099       }
    2100       else
    2101       {
    2102         r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
    2103         rect.top += GetSystemMetrics(SM_CYCAPTION);
    2104       }
    2105       if( !clip || IntersectRect( &rfuzz, &r, &rectClip ) )
    2106         DrawCaption(hdc, &r, active);
    2107     }
    2108   }
    2109   if (HAS_MENU())
    2110   {
    2111     RECT r = rect;
    2112     r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
    2113 
    2114     rect.top += MENU_DrawMenuBar( hdc, &r, Win32Hwnd, suppress_menupaint ) + 1;
    2115   }
    2116 
    2117   if (dwExStyle & WS_EX_CLIENTEDGE)
    2118     DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
    2119 
    2120   if (dwExStyle & WS_EX_STATICEDGE)
    2121     DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
    2122 
    2123   /* Draw the scroll-bars */
    2124   if (dwStyle & WS_VSCROLL)
    2125     SCROLL_DrawScrollBar(Win32Hwnd,hdc,SB_VERT,TRUE,TRUE);
    2126   if (dwStyle & WS_HSCROLL)
    2127     SCROLL_DrawScrollBar(Win32Hwnd,hdc,SB_HORZ,TRUE,TRUE);
    2128 
    2129   /* Draw the "size-box" */
    2130   if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
    2131   {
    2132     RECT r = rect;
    2133     r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
    2134     r.top  = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
    2135     FillRect( hdc, &r,  GetSysColorBrush(COLOR_SCROLLBAR) );
    2136     if (!(dwStyle & WS_CHILD))
    2137     {
    2138       POINT p1,p2;
    2139       HPEN penDark = GetSysColorPen(COLOR_3DSHADOW);
    2140       HPEN penWhite = GetSysColorPen(COLOR_3DHILIGHT);
    2141       HPEN oldPen = SelectObject(hdc,penDark);
    2142       INT x;
    2143 
    2144       p1.x = r.right-1;
    2145       p1.y = r.bottom;
    2146       p2.x = r.right;
    2147       p2.y = r.bottom-1;
    2148       for (x = 0;x < 3;x++)
    2149       {
    2150         SelectObject(hdc,penDark);
    2151         MoveToEx(hdc,p1.x,p1.y,NULL);
    2152         LineTo(hdc,p2.x,p2.y);
    2153         p1.x--;
    2154         p2.y--;
    2155         MoveToEx(hdc,p1.x,p1.y,NULL);
    2156         LineTo(hdc,p2.x,p2.y);
    2157         SelectObject(hdc,penWhite);
    2158         p1.x--;
    2159         p2.y--;
    2160         MoveToEx(hdc,p1.x,p1.y,NULL);
    2161         LineTo(hdc,p2.x,p2.y);
    2162         p1.x -= 2;
    2163         p2.y -= 2;
    2164       }
    2165 
    2166       SelectObject(hdc,oldPen);
    2167     }
    2168   }
    2169 
    2170   ReleaseDC(Win32Hwnd,hdc);
    2171 }
    2172 //******************************************************************************
    2173 //******************************************************************************
    2174 LONG Win32BaseWindow::HandleNCPaint(HRGN clip)
    2175 {
    2176 //CB: ignore it for now (SetWindowPos in WM_CREATE)
    2177 //  if (!(dwStyle & WS_VISIBLE)) return 0;
    2178 
    2179   if (dwStyle & WS_MINIMIZE) return 0;
    2180 
    2181   DoNCPaint(clip,FALSE);
    2182 
    2183   return 0;
    2184 }
    2185 /***********************************************************************
    2186  *           NC_HandleNCLButtonDblClk
    2187  *
    2188  * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
    2189  */
    2190 LONG Win32BaseWindow::HandleNCLButtonDblClk(WPARAM wParam,LPARAM lParam)
    2191 {
    2192   /*
    2193    * if this is an icon, send a restore since we are handling
    2194    * a double click
    2195    */
    2196   if (dwStyle & WS_MINIMIZE)
    2197   {
    2198     SendInternalMessageA(WM_SYSCOMMAND,SC_RESTORE,lParam);
    2199     return 0;
    2200   }
    2201 
    2202   switch(wParam)  /* Hit test */
    2203   {
    2204     case HTCAPTION:
    2205       /* stop processing if WS_MAXIMIZEBOX is missing */
    2206       if (dwStyle & WS_MAXIMIZEBOX)
    2207         SendInternalMessageA(WM_SYSCOMMAND,
    2208                       (dwStyle & WS_MAXIMIZE) ? SC_RESTORE : SC_MAXIMIZE,
    2209                       lParam);
    2210       break;
    2211 
    2212     case HTSYSMENU:
    2213       if (!(GetClassWord(Win32Hwnd,GCW_STYLE) & CS_NOCLOSE))
    2214         SendInternalMessageA(WM_SYSCOMMAND,SC_CLOSE,lParam);
    2215       break;
    2216 
    2217     case HTHSCROLL:
    2218       SendInternalMessageA(WM_SYSCOMMAND,SC_HSCROLL+HTHSCROLL,lParam);
    2219       break;
    2220 
    2221     case HTVSCROLL:
    2222       SendInternalMessageA(WM_SYSCOMMAND,SC_VSCROLL+HTVSCROLL,lParam);
    2223       break;
    2224   }
    2225 
    2226   return 0;
    2227 }
    2228 /***********************************************************************
    2229  *           NC_HandleSysCommand
    2230  *
    2231  * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
    2232  *
    2233  * TODO: Not done (see #if 0)
    2234  */
    2235 LONG Win32BaseWindow::HandleSysCommand(WPARAM wParam,POINT *pt32)
    2236 {
    2237     UINT uCommand = wParam & 0xFFF0;
    2238 
    2239 /* //CB: don't need this, perhaps recycle for menus
    2240     if ((getStyle() & WS_CHILD) && (uCommand != SC_KEYMENU))
    2241         ScreenToClient(getParent()->getWindowHandle(), pt32 );
    2242 */
    2243     switch (uCommand)
    2244     {
    2245 
    2246     case SC_SIZE:
    2247     {
    2248       DWORD flags = 0;
    2249 
    2250       switch ((wParam & 0xF)+2)
    2251       {
    2252         case HTLEFT:
    2253           flags = TFOS_LEFT;
    2254           break;
    2255 
    2256         case HTRIGHT:
    2257           flags = TFOS_RIGHT;
    2258           break;
    2259 
    2260         case HTTOP:
    2261           flags = TFOS_TOP;
    2262           break;
    2263 
    2264         case HTTOPLEFT:
    2265           flags = TFOS_TOP | TFOS_LEFT;
    2266           break;
    2267 
    2268         case HTTOPRIGHT:
    2269           flags = TFOS_TOP | TFOS_RIGHT;
    2270           break;
    2271 
    2272         case HTBOTTOM:
    2273           flags = TFOS_BOTTOM;
    2274           break;
    2275 
    2276         case HTBOTTOMLEFT:
    2277           flags = TFOS_BOTTOM | TFOS_LEFT;
    2278           break;
    2279 
    2280         case HTBOTTOMRIGHT:
    2281           flags = TFOS_BOTTOM | TFOS_RIGHT;
    2282           break;
    2283       }
    2284       if (flags) FrameTrackFrame(this,flags);
    2285       break;
    2286     }
    2287 
    2288     case SC_MOVE:
    2289       FrameTrackFrame(this,TFOS_MOVE);
    2290       break;
    2291 
    2292     case SC_MINIMIZE:
    2293         ShowWindow(SW_MINIMIZE);
    2294         break;
    2295 
    2296     case SC_MAXIMIZE:
    2297         ShowWindow(SW_MAXIMIZE);
    2298         break;
    2299 
    2300     case SC_RESTORE:
    2301         ShowWindow(SW_RESTORE);
    2302         break;
    2303 
    2304     case SC_CLOSE:
    2305         return SendInternalMessageA(WM_CLOSE,0,0);
    2306 
    2307     case SC_VSCROLL:
    2308     case SC_HSCROLL:
    2309         TrackScrollBar(wParam,*pt32);
    2310         break;
    2311 
    2312     case SC_MOUSEMENU:
    2313         MENU_TrackMouseMenuBar(Win32Hwnd,wParam & 0x000F,*pt32);
    2314         break;
    2315 
    2316     case SC_KEYMENU:
    2317         MENU_TrackKbdMenuBar(Win32Hwnd,wParam,pt32->x);
    2318         break;
    2319 
    2320     case SC_TASKLIST:
    2321         WinExec("taskman.exe",SW_SHOWNORMAL);
    2322         break;
    2323 
    2324     case SC_SCREENSAVE:
    2325         if (wParam == SC_ABOUTWINE)
    2326             ShellAboutA(Win32Hwnd,"Odin","Odin alpha release compiled with IBM VAC++",0);
    2327         else
    2328         if (wParam == SC_PUTMARK)
    2329             dprintf(("Mark requested by user\n"));
    2330         break;
    2331 
    2332     case SC_HOTKEY:
    2333     case SC_ARRANGE:
    2334     case SC_NEXTWINDOW:
    2335     case SC_PREVWINDOW:
    2336         break;
    2337     }
    2338     return 0;
    2339 }
    2340 //******************************************************************************
    2341 //******************************************************************************
    23421195LRESULT Win32BaseWindow::DefWndControlColor(UINT ctlType, HDC hdc)
    23431196{
    … …  
    24861339        setStyle(getStyle() | WS_VISIBLE);
    24871340        OSLibWinEnableWindowUpdate(OS2HwndFrame,TRUE);
    2488       } else
     1341      }
     1342      else
    24891343      {
    24901344        if (getStyle() & WS_VISIBLE)
    … …  
    24961350      return 0;
    24971351    }
    2498 
    2499     case WM_NCPAINT:
    2500          return HandleNCPaint((HRGN)wParam);
    2501 
    2502     case WM_NCACTIVATE:
    2503         return HandleNCActivate(wParam);
    2504 
    2505     case WM_NCCREATE:
    2506         return(TRUE);
    2507 
    2508     case WM_NCDESTROY:
    2509         return 0;
    2510 
    2511     case WM_NCCALCSIZE:
    2512         return HandleNCCalcSize((BOOL)wParam,(RECT*)lParam);
    25131352
    25141353    case WM_CTLCOLORMSGBOX:
    … …  
    26741513    case WM_GETDLGCODE:
    26751514        return 0;
     1515
     1516    case WM_NCPAINT:
     1517         return HandleNCPaint((HRGN)wParam);
     1518
     1519    case WM_NCACTIVATE:
     1520        return HandleNCActivate(wParam);
     1521
     1522    case WM_NCCREATE:
     1523        return(TRUE);
     1524
     1525    case WM_NCDESTROY:
     1526        return 0;
     1527
     1528    case WM_NCCALCSIZE:
     1529        return HandleNCCalcSize((BOOL)wParam,(RECT*)lParam);
    26761530
    26771531    case WM_NCLBUTTONDOWN:
Note: See TracChangeset for help on using the changeset viewer.