From 1c19d25eb3cf504b285969e214327e5d3df6de22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Gardou?= Date: Tue, 21 Oct 2014 18:59:44 +0000 Subject: [PATCH] [WIN32K] - "Convert" new cursor & icons implementation to the new user object handle manager. - Fix a few idiosyncracies in the way cursor handles are used (only with USE_NEW_CURSORICON_ENABLED) [WIN32SS] - Storm out the flowers out of how classes use icon and cursor objects, with proper refcounting and all those joyous things. Handles are for the powerless, kernel mode use pointers. Only with USE_NEW_CURSORICON enabled (soon!) CORE-7575 svn path=/trunk/; revision=64877 --- reactos/win32ss/include/ntuser.h | 12 +- reactos/win32ss/user/ntuser/class.c | 227 +++++++++++++++++-- reactos/win32ss/user/ntuser/cursoricon.h | 12 +- reactos/win32ss/user/ntuser/cursoricon_new.c | 193 ++++++---------- reactos/win32ss/user/ntuser/defwnd.c | 107 +++++++-- reactos/win32ss/user/ntuser/main.c | 5 + reactos/win32ss/user/ntuser/object.c | 8 + reactos/win32ss/user/ntuser/object.h | 2 + reactos/win32ss/user/ntuser/painting.c | 16 +- reactos/win32ss/user/ntuser/painting.h | 2 +- reactos/win32ss/user/ntuser/windc.c | 3 +- reactos/win32ss/user/ntuser/window.c | 20 +- reactos/win32ss/user/user32/windows/class.c | 27 +++ 13 files changed, 461 insertions(+), 173 deletions(-) diff --git a/reactos/win32ss/include/ntuser.h b/reactos/win32ss/include/ntuser.h index be603583838..c89f8523295 100644 --- a/reactos/win32ss/include/ntuser.h +++ b/reactos/win32ss/include/ntuser.h @@ -521,18 +521,24 @@ typedef struct _CLS INT cbclsExtra; INT cbwndExtra; HINSTANCE hModule; +#ifdef NEW_CURSORICON + struct _CURICON_OBJECT* spicn; + struct _CURICON_OBJECT* spcur; +#else HANDLE hIcon; /* FIXME - Use pointer! */ - //PCURSOR spicn; HANDLE hCursor; /* FIXME - Use pointer! */ - //PCURSOR spcur; +#endif HBRUSH hbrBackground; PWSTR lpszMenuName; // kernel use PSTR lpszAnsiClassName; // " +#ifdef NEW_CURSORICON + struct _CURICON_OBJECT* spicnSm; +#else HANDLE hIconSm; /* FIXME - Use pointer! */ - //PCURSOR spicnSm; //// ReactOS dosn't suppot cache icons. HICON hIconSmIntern; /* Internal small icon, derived from hIcon */ +#endif //// UINT Unicode : 1; // !CSF_ANSIPROC UINT Global : 1; // CS_GLOBALCLASS or CSF_SERVERSIDEPROC diff --git a/reactos/win32ss/user/ntuser/class.c b/reactos/win32ss/user/ntuser/class.c index f14071e3ea8..dfe3e9c2110 100644 --- a/reactos/win32ss/user/ntuser/class.c +++ b/reactos/win32ss/user/ntuser/class.c @@ -245,8 +245,17 @@ IntDestroyClass(IN OUT PCLS Class) IntFreeClassMenuName(Class); } +#ifdef NEW_CURSORICON + if (Class->spicn) + UserDereferenceObject(Class->spicn); + if (Class->spicnSm) + UserDereferenceObject(Class->spicnSm); + if (Class->spcur) + UserDereferenceObject(Class->spcur); +#else if (Class->hIconSmIntern) IntClassDestroyIcon(Class->hIconSmIntern); +#endif pDesk = Class->rpdeskParent; Class->rpdeskParent = NULL; @@ -587,11 +596,22 @@ IntGetClassForDesktop(IN OUT PCLS BaseClass, Class = DesktopHeapAlloc(Desktop, ClassSize); + if (Class != NULL) { /* Simply clone the class */ RtlCopyMemory( Class, BaseClass, ClassSize); +#ifdef NEW_CURSORICON + /* Reference our objects */ + if (Class->spcur) + UserReferenceObject(Class->spcur); + if (Class->spicn) + UserReferenceObject(Class->spicn); + if (Class->spicnSm) + UserReferenceObject(Class->spicnSm); +#endif + TRACE("Clone Class 0x%p hM 0x%p\n %S\n",Class, Class->hModule, Class->lpszClientUnicodeMenuName); /* Restore module address if default user class Ref: Bug 4778 */ @@ -1009,10 +1029,15 @@ IntCreateClass(IN CONST WNDCLASSEXW* lpwcx, Class->cbclsExtra = lpwcx->cbClsExtra; Class->cbwndExtra = lpwcx->cbWndExtra; Class->hModule = lpwcx->hInstance; - //// FIXME handles to pointers +#ifdef NEW_CURSORICON + Class->spicn = lpwcx->hIcon ? UserGetCurIconObject(lpwcx->hIcon) : NULL; + Class->spcur = lpwcx->hCursor ? UserGetCurIconObject(lpwcx->hCursor) : NULL; + Class->spicnSm = lpwcx->hIconSm ? UserGetCurIconObject(lpwcx->hIconSm) : NULL; +#else Class->hIcon = lpwcx->hIcon; Class->hIconSm = lpwcx->hIconSm; Class->hCursor = lpwcx->hCursor; +#endif //// Class->hbrBackground = lpwcx->hbrBackground; @@ -1726,13 +1751,7 @@ IntSetClassMenuName(IN PCLS Class, return Ret; } -//// Do this for now in anticipation of new cursor icon code. #ifndef NEW_CURSORICON -BOOLEAN FASTCALL IntDestroyCurIconObject(PCURICON_OBJECT, PPROCESSINFO); -#else -BOOLEAN FASTCALL IntDestroyCurIconObject(PCURICON_OBJECT, BOOLEAN); -#endif - BOOL FASTCALL IntClassDestroyIcon(HANDLE hCurIcon) { @@ -1745,19 +1764,15 @@ IntClassDestroyIcon(HANDLE hCurIcon) ERR("hCurIcon was not found!\n"); return FALSE; } -#ifndef NEW_CURSORICON - Ret = IntDestroyCurIconObject(CurIcon, PsGetCurrentProcessWin32Process()); - /* Note: IntDestroyCurIconObject will remove our reference for us! */ -#else /* Note: IntDestroyCurIconObject will remove our reference for us! */ Ret = IntDestroyCurIconObject(CurIcon, TRUE); -#endif if (!Ret) { ERR("hCurIcon was not Destroyed!\n"); } return Ret; } +#endif ULONG_PTR UserSetClassLongPtr(IN PCLS Class, @@ -1766,7 +1781,9 @@ UserSetClassLongPtr(IN PCLS Class, IN BOOL Ansi) { ULONG_PTR Ret = 0; +#ifndef NEW_CURSORICON HANDLE hIconSmIntern = NULL; +#endif /* NOTE: For GCLP_MENUNAME and GCW_ATOM this function may raise an exception! */ @@ -1838,6 +1855,54 @@ UserSetClassLongPtr(IN PCLS Class, } break; +#ifdef NEW_CURSORICON + case GCLP_HCURSOR: + { + PCURICON_OBJECT NewCursor = NULL; + + if (NewLong) + { + NewCursor = UserGetCurIconObject((HCURSOR)NewLong); + if (!NewCursor) + { + EngSetLastError(ERROR_INVALID_CURSOR_HANDLE); + return 0; + } + } + + if (Class->spcur) + { + Ret = (ULONG_PTR)UserHMGetHandle(Class->spcur); + UserDereferenceObject(Class->spcur); + } + else + { + Ret = 0; + } + + if (Ret == NewLong) + { + /* It's a nop */ + return Ret; + } + + Class->spcur = NewCursor; + + /* Update the clones */ + Class = Class->pclsClone; + while (Class != NULL) + { + if (Class->spcur) + UserDereferenceObject(Class->spcur); + if (NewCursor) + UserReferenceObject(NewCursor); + Class->spcur = NewCursor; + Class = Class->pclsNext; + } + + break; + } +#else case GCLP_HCURSOR: /* FIXME: Get handle from pointer to CURSOR object */ Ret = (ULONG_PTR)Class->hCursor; @@ -1851,6 +1916,7 @@ UserSetClassLongPtr(IN PCLS Class, Class = Class->pclsNext; } break; +#endif // MSDN: // hIconSm, A handle to a small icon that is associated with the window class. @@ -1858,6 +1924,88 @@ UserSetClassLongPtr(IN PCLS Class, // the hIcon member for an icon of the appropriate size to use as the small icon. // case GCLP_HICON: +#ifdef NEW_CURSORICON + { + PCURICON_OBJECT NewIcon = NULL; + PCURICON_OBJECT NewSmallIcon = NULL; + + if (NewLong) + { + NewIcon = UserGetCurIconObject((HCURSOR)NewLong); + if (!NewIcon) + { + EngSetLastError(ERROR_INVALID_ICON_HANDLE); + return 0; + } + } + + if (Class->spicn) + { + Ret = (ULONG_PTR)UserHMGetHandle(Class->spicn); + UserDereferenceObject(Class->spicn); + } + else + { + Ret = 0; + } + + if (Ret == NewLong) + { + /* It's a nop */ + return Ret; + } + + if (Ret && (Class->CSF_flags & CSF_CACHEDSMICON)) + { + /* We will change the small icon */ + UserDereferenceObject(Class->spicnSm); + Class->spicnSm = NULL; + Class->CSF_flags &= ~CSF_CACHEDSMICON; + } + + if (NewLong && !Class->spicnSm) + { + /* Create the new small icon from the new large(?) one */ + HICON SmallIconHandle = co_IntCopyImage( + (HICON)NewLong, + IMAGE_ICON, + UserGetSystemMetrics( SM_CXSMICON ), + UserGetSystemMetrics( SM_CYSMICON ), + 0); + if (SmallIconHandle) + { + /* So use it */ + NewSmallIcon = Class->spicnSm = UserGetCurIconObject(SmallIconHandle); + /* Let the handle go, we have the reference on the object */ + NtUserDestroyCursor(SmallIconHandle, FALSE); + Class->CSF_flags |= CSF_CACHEDSMICON; + } + } + + Class->spicn = NewIcon; + + /* Update the clones */ + Class = Class->pclsClone; + while (Class != NULL) + { + if (Class->spicn) + UserDereferenceObject(Class->spicn); + if (NewIcon) + UserReferenceObject(NewIcon); + Class->spicn = NewIcon; + if (NewSmallIcon) + { + if (Class->spicnSm) + UserDereferenceObject(Class->spicnSm); + UserReferenceObject(NewSmallIcon); + Class->spicnSm = NewSmallIcon; + Class->CSF_flags |= CSF_CACHEDSMICON; + } + Class = Class->pclsNext; + } + break; + } +#else /* FIXME: Get handle from pointer to ICON object */ Ret = (ULONG_PTR)Class->hIcon; if (Class->hIcon == (HANDLE)NewLong) break; @@ -1885,8 +2033,51 @@ UserSetClassLongPtr(IN PCLS Class, Class = Class->pclsNext; } break; +#endif case GCLP_HICONSM: +#ifdef NEW_CURSORICON + { + PCURICON_OBJECT NewSmallIcon = NULL; + + if (NewLong) + { + NewSmallIcon = UserGetCurIconObject((HCURSOR)NewLong); + if (!NewSmallIcon) + { + EngSetLastError(ERROR_INVALID_ICON_HANDLE); + return 0; + } + } + + if (Class->spicnSm) + { + Ret = (ULONG_PTR)UserHMGetHandle(Class->spicnSm); + UserDereferenceObject(Class->spicnSm); + } + else + { + Ret = 0; + } + + Class->CSF_flags &= ~CSF_CACHEDSMICON; + Class->spicnSm = NewSmallIcon; + + /* Update the clones */ + Class = Class->pclsClone; + while (Class != NULL) + { + if (Class->spicnSm) + UserDereferenceObject(Class->spicnSm); + if (NewSmallIcon) + UserReferenceObject(NewSmallIcon); + Class->CSF_flags &= ~CSF_CACHEDSMICON; + Class->spicnSm = NewSmallIcon; + Class = Class->pclsNext; + } + } + break; +#else /* FIXME: Get handle from pointer to ICON object */ Ret = (ULONG_PTR)Class->hIconSm; if (Class->hIconSm == (HANDLE)NewLong) break; @@ -1920,6 +2111,7 @@ UserSetClassLongPtr(IN PCLS Class, Class = Class->pclsNext; } break; +#endif case GCLP_HMODULE: Ret = (ULONG_PTR)Class->hModule; @@ -2011,8 +2203,16 @@ UserGetClassInfo(IN PCLS Class, lpwcx->cbClsExtra = Class->cbclsExtra; lpwcx->cbWndExtra = Class->cbwndExtra; +#ifdef NEW_CURSORICON + lpwcx->hIcon = Class->spicn ? UserHMGetHandle(Class->spicn) : NULL; + lpwcx->hCursor = Class->spcur ? UserHMGetHandle(Class->spcur) : NULL; + lpwcx->hIconSm = Class->spicnSm ? UserHMGetHandle(Class->spicnSm) : NULL; +#else lpwcx->hIcon = Class->hIcon; /* FIXME: Get handle from pointer */ lpwcx->hCursor = Class->hCursor; /* FIXME: Get handle from pointer */ + /* FIXME: Get handle from pointer */ + lpwcx->hIconSm = Class->hIconSm ? Class->hIconSm : Class->hIconSmIntern; +#endif lpwcx->hbrBackground = Class->hbrBackground; /* Copy non-string to user first. */ @@ -2042,9 +2242,6 @@ UserGetClassInfo(IN PCLS Class, /* FIXME: Return the string? Okay! This is performed in User32! */ //lpwcx->lpszClassName = (LPCWSTR)((ULONG_PTR)Class->atomClassName); - /* FIXME: Get handle from pointer */ - lpwcx->hIconSm = Class->hIconSm ? Class->hIconSm : Class->hIconSmIntern; - return TRUE; } diff --git a/reactos/win32ss/user/ntuser/cursoricon.h b/reactos/win32ss/user/ntuser/cursoricon.h index c6b998a8d52..d62453f2b9d 100644 --- a/reactos/win32ss/user/ntuser/cursoricon.h +++ b/reactos/win32ss/user/ntuser/cursoricon.h @@ -41,6 +41,12 @@ typedef struct tagACON C_ASSERT(FIELD_OFFSET(ACON, cpcur) == FIELD_OFFSET(CURICON_OBJECT, xHotspot)); +BOOLEAN +IntDestroyCurIconObject(PVOID Object); + +VOID FASTCALL +IntCleanupCurIconCache(PPROCESSINFO Win32Process); + #else typedef struct tagCURICON_PROCESS @@ -62,6 +68,9 @@ typedef struct _CURICON_OBJECT BYTE Shadow; ICONINFO IconInfo; } CURICON_OBJECT, *PCURICON_OBJECT; +BOOLEAN FASTCALL IntDestroyCurIconObject(PCURICON_OBJECT CurIcon, PPROCESSINFO ppi); +BOOL FASTCALL IntDestroyCursor(HANDLE hCurIcon, BOOL bForce); +HCURSOR FASTCALL IntSetCursor(HCURSOR hCursor); #endif typedef struct _CURSORACCELERATION_INFO @@ -112,9 +121,6 @@ PCURICON_OBJECT FASTCALL UserGetCurIconObject(HCURSOR hCurIcon); BOOL UserSetCursorPos( INT x, INT y, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook); BOOL APIENTRY UserClipCursor(RECTL *prcl); PSYSTEM_CURSORINFO IntGetSysCursorInfo(VOID); -HCURSOR FASTCALL IntSetCursor(HCURSOR hCursor); -BOOL FASTCALL IntDestroyCursor(HANDLE hCurIcon, BOOL bForce); -BOOLEAN FASTCALL IntDestroyCurIconObject(PCURICON_OBJECT CurIcon, PPROCESSINFO ppi); #define IntReleaseCurIconObject(CurIconObj) \ UserDereferenceObject(CurIconObj) diff --git a/reactos/win32ss/user/ntuser/cursoricon_new.c b/reactos/win32ss/user/ntuser/cursoricon_new.c index 40e28458ea2..9beedbaab22 100644 --- a/reactos/win32ss/user/ntuser/cursoricon_new.c +++ b/reactos/win32ss/user/ntuser/cursoricon_new.c @@ -133,7 +133,7 @@ IntCreateCurIconHandle(BOOLEAN Animated) CurIcon = UserCreateObject( gHandleTable, NULL, - NULL, + GetW32ThreadInfo(), &hCurIcon, TYPE_CURSOR, Animated ? sizeof(ACON) : sizeof(CURICON_OBJECT)); @@ -149,35 +149,11 @@ IntCreateCurIconHandle(BOOLEAN Animated) return hCurIcon; } -BOOLEAN FASTCALL -IntDestroyCurIconObject(PCURICON_OBJECT CurIcon, BOOLEAN bForce) +BOOLEAN +IntDestroyCurIconObject(PVOID Object) { - if(CurIcon->CURSORF_flags & CURSORF_CURRENT) - { - /* Mark the object as destroyed, and fail, as per tests */ - TRACE("Cursor is current, marking as destroyed.\n"); - UserDeleteObject(CurIcon->head.h, TYPE_CURSOR); - return FALSE; - } - - if(CurIcon->head.ppi != PsGetCurrentProcessWin32Process()) - { - /* This object doesn't belong to the current process */ - WARN("Trying to delete foreign cursor!\n"); - UserDereferenceObject(CurIcon); - EngSetLastError(ERROR_DESTROY_OBJECT_OF_OTHER_THREAD); - return FALSE; - } + PCURICON_OBJECT CurIcon = Object; - /* Do not destroy it if it is shared. (And we're not forced to) */ - if((CurIcon->CURSORF_flags & CURSORF_LRSHARED) && !bForce) - { - /* Tests show this is a valid call */ - WARN("Trying to destroy shared cursor!\n"); - UserDereferenceObject(CurIcon); - return TRUE; - } - if(!(CurIcon->CURSORF_flags & CURSORF_ACON)) { HBITMAP bmpMask = CurIcon->hbmMask; @@ -210,103 +186,57 @@ IntDestroyCurIconObject(PCURICON_OBJECT CurIcon, BOOLEAN bForce) UINT i; for(i = 0; i < AniCurIcon->cpcur; i++) - IntDestroyCurIconObject(AniCurIcon->aspcur[i], TRUE); + IntDestroyCurIconObject(AniCurIcon->aspcur[i]); ExFreePoolWithTag(AniCurIcon->aspcur, USERTAG_CURSOR); } if (CurIcon->CURSORF_flags & CURSORF_LRSHARED) { + PPROCESSINFO ppi; + if (!IS_INTRESOURCE(CurIcon->strName.Buffer)) ExFreePoolWithTag(CurIcon->strName.Buffer, TAG_STRING); if (CurIcon->atomModName) RtlDeleteAtomFromAtomTable(gAtomTable, CurIcon->atomModName); CurIcon->strName.Buffer = NULL; CurIcon->atomModName = 0; + + /* Try finding it in its process cache */ + ppi = CurIcon->head.ppi; + if (ppi->pCursorCache == CurIcon) + ppi->pCursorCache = CurIcon->pcurNext; + else + { + PCURICON_OBJECT CacheCurIcon= ppi->pCursorCache; + while (CacheCurIcon) + { + if (CacheCurIcon->pcurNext == CurIcon) + { + CacheCurIcon->pcurNext = CurIcon->pcurNext; + break; + } + CacheCurIcon = CacheCurIcon->pcurNext; + } + } } - /* We were given a pointer, no need to keep the reference any longer! */ - UserDereferenceObject(CurIcon); - return UserDeleteObject(CurIcon->head.h, TYPE_CURSOR); + return TRUE; } VOID FASTCALL -IntCleanupCurIcons(struct _EPROCESS *Process, PPROCESSINFO Win32Process) +IntCleanupCurIconCache(PPROCESSINFO Win32Process) { PCURICON_OBJECT CurIcon; /* Run through the list of icon objects */ - while(Win32Process->pCursorCache) + while (Win32Process->pCursorCache) { CurIcon = Win32Process->pCursorCache; Win32Process->pCursorCache = CurIcon->pcurNext; - /* One ref for the handle, one for the list, - * and potentially one from an other process via SetCursor */ - ASSERT(CurIcon->head.cLockObj <= 3); - IntDestroyCurIconObject(CurIcon, TRUE); + UserDereferenceObject(CurIcon); } } -HCURSOR FASTCALL -IntSetCursor( - HCURSOR hCursor) -{ - PCURICON_OBJECT pcurOld, pcurNew; - HCURSOR hOldCursor = NULL; - - if (hCursor) - { - pcurNew = UserGetCurIconObject(hCursor); - if (!pcurNew) - { - EngSetLastError(ERROR_INVALID_CURSOR_HANDLE); - goto leave; - } - pcurNew->CURSORF_flags |= CURSORF_CURRENT; - } - else - { - pcurNew = NULL; - } - - pcurOld = UserSetCursor(pcurNew, FALSE); - if (pcurOld) - { - hOldCursor = pcurOld->head.h; - pcurOld->CURSORF_flags &= ~CURSORF_CURRENT; - if(UserObjectInDestroy(hOldCursor)) - { - /* Destroy it once and for all */ - IntDestroyCurIconObject(pcurOld, TRUE); - hOldCursor = NULL; - } - else - { - UserDereferenceObject(pcurOld); - } - } -leave: - return hOldCursor; -} - -BOOL FASTCALL -IntDestroyCursor( - HANDLE hCurIcon, - BOOL bForce) -{ - PCURICON_OBJECT CurIcon; - BOOL ret; - - if (!(CurIcon = UserGetCurIconObject(hCurIcon))) - { - return(FALSE); - } - - ret = IntDestroyCurIconObject(CurIcon, bForce); - /* Note: IntDestroyCurIconObject will remove our reference for us! */ - - return ret; -} - /* * @implemented */ @@ -690,27 +620,56 @@ NtUserDestroyCursor( _In_ HANDLE hCurIcon, _In_ BOOL bForce) { - PCURICON_OBJECT CurIcon; BOOL ret; - DECLARE_RETURN(BOOL); TRACE("Enter NtUserDestroyCursorIcon\n"); UserEnterExclusive(); - if (!(CurIcon = UserGetCurIconObject(hCurIcon))) + if (!bForce) { - RETURN(FALSE); + /* Maybe we have good reasons not to destroy this object */ + PCURICON_OBJECT CurIcon = UserGetCurIconObject(hCurIcon); + ULONG Flags; + if (!CurIcon) + { + ret = FALSE; + goto leave; + } + + if (CurIcon->head.ppi != PsGetCurrentProcessWin32Process()) + { + /* No way, you're not touching my cursor */ + ret = FALSE; + UserDereferenceObject(CurIcon); + goto leave; + } + + Flags = CurIcon->CURSORF_flags; + UserDereferenceObject(CurIcon); + + if (Flags & CURSORF_CURRENT) + { + WARN("Trying to delete current cursor!\n"); + ret = FALSE; + goto leave; + } + + if (Flags & CURSORF_LRSHARED) + { + WARN("Trying to delete shared cursor.\n"); + /* This one is not an error */ + ret = TRUE; + goto leave; + } } - ret = IntDestroyCurIconObject(CurIcon, bForce); - /* Note: IntDestroyCurIconObject will remove our reference for us! */ + /* Destroy the handle */ + ret = UserDeleteObject(hCurIcon, TYPE_CURSOR); - RETURN(ret); - -CLEANUP: - TRACE("Leave NtUserDestroyCursorIcon, ret=%i\n",_ret_); +leave: + TRACE("Leave NtUserDestroyCursorIcon, ret=%i\n", ret); UserLeave(); - END_CLEANUP; + return ret; } @@ -891,18 +850,8 @@ NtUserSetCursor( pcurOld = UserSetCursor(pcurNew, FALSE); if (pcurOld) { - hOldCursor = pcurOld->head.h; pcurOld->CURSORF_flags &= ~CURSORF_CURRENT; - if(UserObjectInDestroy(hOldCursor)) - { - /* Destroy it once and for all */ - IntDestroyCurIconObject(pcurOld, TRUE); - hOldCursor = NULL; - } - else - { - UserDereferenceObject(pcurOld); - } + UserDereferenceObject(pcurOld); } leave: @@ -1088,7 +1037,7 @@ done: for(i = 0; i < numFrames; i++) { if(AniCurIcon->aspcur[i]) - IntDestroyCurIconObject(AniCurIcon->aspcur[i], TRUE); + IntDestroyCurIconObject(AniCurIcon->aspcur[i]); } AniCurIcon->cicur = 0; AniCurIcon->cpcur = 0; diff --git a/reactos/win32ss/user/ntuser/defwnd.c b/reactos/win32ss/user/ntuser/defwnd.c index b4c00df7ea0..4ca3b2da0a1 100644 --- a/reactos/win32ss/user/ntuser/defwnd.c +++ b/reactos/win32ss/user/ntuser/defwnd.c @@ -387,7 +387,11 @@ DefWndDoSizeMove(PWND pwnd, WORD wParam) RECT sizingRect, mouseRect, origRect, unmodRect; HDC hdc; LONG hittest = (LONG)(wParam & 0x0f); +#ifdef NEW_CURSORICON + PCURICON_OBJECT DragCursor = NULL, OldCursor = NULL; +#else HCURSOR hDragCursor = 0, hOldCursor = 0; +#endif POINT minTrack, maxTrack; POINT capturePoint, pt; ULONG Style, ExStyle; @@ -495,13 +499,35 @@ DefWndDoSizeMove(PWND pwnd, WORD wParam) } hdc = UserGetDCEx( pWndParent, 0, DCX_CACHE ); - +#ifdef NEW_CURSORICON + if (iconic) + { + DragCursor = pwnd->pcls->spicn; + if (DragCursor) + { + UserReferenceObject(DragCursor); + } + else + { + HCURSOR CursorHandle = (HCURSOR)co_IntSendMessage( UserHMGetHandle(pwnd), WM_QUERYDRAGICON, 0, 0 ); + if (CursorHandle) + { + DragCursor = UserGetCurIconObject(CursorHandle); + } + else + { + iconic = FALSE; + } + } + } +#else if ( iconic ) /* create a cursor for dragging */ { - hDragCursor = pwnd->pcls->hIcon;; + hDragCursor = pwnd->pcls->hIcon; if ( !hDragCursor ) hDragCursor = (HCURSOR)co_IntSendMessage( UserHMGetHandle(pwnd), WM_QUERYDRAGICON, 0, 0 ); if ( !hDragCursor ) iconic = FALSE; } +#endif /* repaint the window before moving it around */ co_UserRedrawWindow( pwnd, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN); @@ -558,14 +584,17 @@ DefWndDoSizeMove(PWND pwnd, WORD wParam) if ( !moved ) { moved = TRUE; - - if ( iconic ) /* ok, no system popup tracking */ - { - hOldCursor = IntSetCursor(hDragCursor); - UserShowCursor( TRUE ); - } - else if(!DragFullWindows) - UserDrawMovingFrame( hdc, &sizingRect, thickframe ); + if ( iconic ) /* ok, no system popup tracking */ + { +#ifdef NEW_CURSORICON + OldCursor = UserSetCursor(DragCursor, FALSE); +#else + hOldCursor = IntSetCursor(hDragCursor); +#endif + UserShowCursor( TRUE ); + } + else if(!DragFullWindows) + UserDrawMovingFrame( hdc, &sizingRect, thickframe ); } if (msg.message == WM_KEYDOWN) UserSetCursorPos(pt.x, pt.y, 0, 0, FALSE); @@ -644,10 +673,18 @@ DefWndDoSizeMove(PWND pwnd, WORD wParam) { if ( moved ) /* restore cursors, show icon title later on */ { - UserShowCursor( FALSE ); - IntSetCursor( hOldCursor ); + UserShowCursor( FALSE ); +#ifdef NEW_CURSORICON + UserSetCursor(OldCursor, FALSE); +#else + IntSetCursor( hOldCursor ); +#endif } +#ifdef NEW_CURSORICON + UserDereferenceObject(DragCursor); +#else IntDestroyCursor( hDragCursor, FALSE ); +#endif } else if ( moved && !DragFullWindows ) UserDrawMovingFrame( hdc, &sizingRect, thickframe ); @@ -990,6 +1027,19 @@ IntDefWindowProc( hDC = IntBeginPaint(Wnd, &Ps); if (hDC) { +#ifdef NEW_CURSORICON + if (((Wnd->style & WS_MINIMIZE) != 0) && (Wnd->pcls->spicn)) + { + RECT ClientRect; + INT x, y; + + ERR("Doing Paint and Client area is empty!\n"); + IntGetClientRect(Wnd, &ClientRect); + x = (ClientRect.right - ClientRect.left - UserGetSystemMetrics(SM_CXICON)) / 2; + y = (ClientRect.bottom - ClientRect.top - UserGetSystemMetrics(SM_CYICON)) / 2; + UserDrawIconEx(hDC, x, y, Wnd->pcls->spicn, 0, 0, 0, 0, DI_NORMAL | DI_COMPAT | DI_DEFAULTSIZE); + } +#else HICON hIcon; if (((Wnd->style & WS_MINIMIZE) != 0) && (hIcon = Wnd->pcls->hIcon)) { @@ -1002,7 +1052,9 @@ IntDefWindowProc( x = (ClientRect.right - ClientRect.left - UserGetSystemMetrics(SM_CXICON)) / 2; y = (ClientRect.bottom - ClientRect.top - UserGetSystemMetrics(SM_CYICON)) / 2; UserDrawIconEx( hDC, x, y, pIcon, 0, 0, 0, 0, DI_NORMAL | DI_COMPAT | DI_DEFAULTSIZE ); + UserDereferenceObject(pIcon) } +#endif IntEndPaint(Wnd, &Ps); } return (0); @@ -1096,23 +1148,38 @@ IntDefWindowProc( return lResult; } -HICON FASTCALL NC_IconForWindow( PWND pWnd ) +PCURICON_OBJECT FASTCALL NC_IconForWindow( PWND pWnd ) { - HICON hIcon = 0; + PCURICON_OBJECT pIcon = NULL; + HICON hIcon; // First thing to do, init the Window Logo icons. if (!gpsi->hIconSmWindows) co_IntSetWndIcons(); - if (!hIcon) hIcon = UserGetProp(pWnd, gpsi->atomIconSmProp); - if (!hIcon) hIcon = UserGetProp(pWnd, gpsi->atomIconProp); - if (!hIcon) hIcon = pWnd->pcls->hIconSm; - if (!hIcon) hIcon = pWnd->pcls->hIcon; + //FIXME: Some callers use this function as if it returns a boolean saying "this window has an icon". + //FIXME: Hence we must return a pointer with no reference count. + //FIXME: This is bad and we should feel bad. - if (!hIcon && pWnd->style & DS_MODALFRAME) + hIcon = UserGetProp(pWnd, gpsi->atomIconSmProp); + if (!hIcon) hIcon = UserGetProp(pWnd, gpsi->atomIconProp); + if (!hIcon && pWnd->pcls->spicnSm) + return pWnd->pcls->spicnSm; + if (!hIcon && pWnd->pcls->spicn) + return pWnd->pcls->spicn; + + if (!hIcon && (pWnd->style & DS_MODALFRAME)) { if (!hIcon) hIcon = gpsi->hIconSmWindows; // Both are IDI_WINLOGO Small if (!hIcon) hIcon = gpsi->hIconWindows; // Reg size. } - return hIcon; + if (hIcon) + { + pIcon = UserGetCurIconObject(hIcon); + if (pIcon) + { + UserDereferenceObject(pIcon); + } + } + return pIcon; } DWORD FASTCALL diff --git a/reactos/win32ss/user/ntuser/main.c b/reactos/win32ss/user/ntuser/main.c index c668bbb27a3..bfc68de9d16 100644 --- a/reactos/win32ss/user/ntuser/main.c +++ b/reactos/win32ss/user/ntuser/main.c @@ -238,6 +238,11 @@ DestroyProcessInfo(PEPROCESS Process) ppiCurrent->hdeskStartup = NULL; } +#ifdef NEW_CURSORICON + /* Clean up the process icon cache */ + IntCleanupCurIconCache(ppiCurrent); +#endif + /* The process is dying */ PsSetProcessWin32Process(Process, NULL, ppiCurrent); ppiCurrent->peProcess = NULL; diff --git a/reactos/win32ss/user/ntuser/object.c b/reactos/win32ss/user/ntuser/object.c index 321d90fedc9..a598807bcb5 100644 --- a/reactos/win32ss/user/ntuser/object.c +++ b/reactos/win32ss/user/ntuser/object.c @@ -218,7 +218,11 @@ static const struct { NULL, NULL, NULL }, /* TYPE_FREE */ { AllocDeskThreadObject, co_UserDestroyWindow, FreeDeskThreadObject }, /* TYPE_WINDOW */ { AllocDeskProcObject, UserDestroyMenuObject, FreeDeskProcObject }, /* TYPE_MENU */ +#ifndef NEW_CURSORICON { AllocProcMarkObject, /*UserCursorCleanup*/NULL, FreeProcMarkObject }, /* TYPE_CURSOR */ +#else + { AllocProcMarkObject, IntDestroyCurIconObject, FreeProcMarkObject }, /* TYPE_CURSOR */ +#endif { AllocSysObject, /*UserSetWindowPosCleanup*/NULL, FreeSysObject }, /* TYPE_SETWINDOWPOS */ { AllocDeskThreadObject, IntRemoveHook, FreeDeskThreadObject }, /* TYPE_HOOK */ { AllocSysObject, /*UserClipDataCleanup*/NULL,FreeSysObject }, /* TYPE_CLIPDATA */ @@ -686,6 +690,7 @@ UserReferenceObjectByHandle(HANDLE handle, HANDLE_TYPE type) return object; } +#ifndef NEW_CURSORICON VOID FASTCALL UserSetObjectOwner(PVOID obj, HANDLE_TYPE type, PVOID owner) @@ -720,6 +725,7 @@ UserSetObjectOwner(PVOID obj, HANDLE_TYPE type, PVOID owner) ppi->UserHandleCount++; IntReferenceProcessInfo(ppi); } +#endif BOOLEAN UserDestroyObjectsForOwner(PUSER_HANDLE_TABLE Table, PVOID Owner) @@ -740,6 +746,7 @@ UserDestroyObjectsForOwner(PUSER_HANDLE_TABLE Table, PVOID Owner) if (Entry->flags & HANDLEENTRY_INDESTROY) continue; +#ifndef NEW_CURSORICON /* Spcial case for cursors until cursoricon_new is there */ if (Entry->type == TYPE_CURSOR) { @@ -750,6 +757,7 @@ UserDestroyObjectsForOwner(PUSER_HANDLE_TABLE Table, PVOID Owner) } continue; } +#endif /* Call destructor */ if (!ObjectCallbacks[Entry->type].ObjectDestroy(Entry->ptr)) diff --git a/reactos/win32ss/user/ntuser/object.h b/reactos/win32ss/user/ntuser/object.h index e90d66cc983..2270fc75f9f 100644 --- a/reactos/win32ss/user/ntuser/object.h +++ b/reactos/win32ss/user/ntuser/object.h @@ -17,7 +17,9 @@ PVOID UserGetObjectNoErr(PUSER_HANDLE_TABLE, HANDLE, HANDLE_TYPE); BOOL FASTCALL UserCreateHandleTable(VOID); BOOL FASTCALL UserObjectInDestroy(HANDLE); void DbgUserDumpHandleTable(); +#ifndef NEW_CURSORICON VOID FASTCALL UserSetObjectOwner(PVOID obj, HANDLE_TYPE type, PVOID owner); +#endif PVOID FASTCALL ValidateHandle(HANDLE handle, HANDLE_TYPE type); BOOLEAN UserDestroyObjectsForOwner(PUSER_HANDLE_TABLE Table, PVOID Owner); diff --git a/reactos/win32ss/user/ntuser/painting.c b/reactos/win32ss/user/ntuser/painting.c index 362bddaa7cf..c6335fb800b 100644 --- a/reactos/win32ss/user/ntuser/painting.c +++ b/reactos/win32ss/user/ntuser/painting.c @@ -2122,13 +2122,17 @@ BOOL UserDrawCaption( { PCURICON_OBJECT pIcon = NULL; - if (!hIcon && pWnd) - { - hIcon = NC_IconForWindow( pWnd ); - } - if (hIcon) - pIcon = UserGetCurIconObject(hIcon); + { + pIcon = UserGetCurIconObject(hIcon); + } + else if (pWnd) + { + pIcon = NC_IconForWindow(pWnd); + // FIXME: NC_IconForWindow should reference it for us */ + if (pIcon) + UserReferenceObject(pIcon); + } if (pIcon) { diff --git a/reactos/win32ss/user/ntuser/painting.h b/reactos/win32ss/user/ntuser/painting.h index 76cf6e07cfd..da08b53d423 100644 --- a/reactos/win32ss/user/ntuser/painting.h +++ b/reactos/win32ss/user/ntuser/painting.h @@ -10,4 +10,4 @@ BOOL FASTCALL IntValidateParent(PWND Child, PREGION ValidateRgn, BOOL Recurse); BOOL FASTCALL IntIsWindowDirty(PWND); BOOL FASTCALL IntEndPaint(PWND,PPAINTSTRUCT); HDC FASTCALL IntBeginPaint(PWND,PPAINTSTRUCT); -HICON FASTCALL NC_IconForWindow( PWND ); +PCURICON_OBJECT FASTCALL NC_IconForWindow( PWND ); diff --git a/reactos/win32ss/user/ntuser/windc.c b/reactos/win32ss/user/ntuser/windc.c index afee0f38f5d..316fe334f4d 100644 --- a/reactos/win32ss/user/ntuser/windc.c +++ b/reactos/win32ss/user/ntuser/windc.c @@ -403,8 +403,7 @@ UserGetDCEx(PWND Wnd OPTIONAL, HANDLE ClipRegion, ULONG Flags) Flags |= DCX_CLIPCHILDREN; } /* If minized with icon in the set, we are forced to be cheap! */ - if (Wnd->style & WS_MINIMIZE && - Wnd->pcls->hIcon) + if (Wnd->style & WS_MINIMIZE && Wnd->pcls->spicn) { Flags |= DCX_CACHE; } diff --git a/reactos/win32ss/user/ntuser/window.c b/reactos/win32ss/user/ntuser/window.c index 9505717328e..9d76efe9b26 100644 --- a/reactos/win32ss/user/ntuser/window.c +++ b/reactos/win32ss/user/ntuser/window.c @@ -1674,7 +1674,24 @@ PWND FASTCALL IntCreateWindow(CREATESTRUCTW* Cs, } pWnd->head.pti->cWindows++; - +#ifdef NEW_CURSORICON + if (Class->spicn && !Class->spicnSm) + { + HICON IconSmHandle = co_IntCopyImage( + UserHMGetHandle(Class->spicn), + IMAGE_ICON, + UserGetSystemMetrics( SM_CXSMICON ), + UserGetSystemMetrics( SM_CYSMICON ), + 0); + if (IconSmHandle) + { + Class->spicnSm = UserGetCurIconObject(IconSmHandle); + /* We can delete the handle, only the pointer is of interest */ + NtUserDestroyCursor(IconSmHandle, FALSE); + Class->CSF_flags |= CSF_CACHEDSMICON; + } + } +#else if (Class->hIcon && !Class->hIconSm) { Class->hIconSmIntern = co_IntCopyImage( Class->hIcon, IMAGE_ICON, @@ -1683,6 +1700,7 @@ PWND FASTCALL IntCreateWindow(CREATESTRUCTW* Cs, TRACE("IntCreateWindow hIconSmIntern %p\n",Class->hIconSmIntern); Class->CSF_flags |= CSF_CACHEDSMICON; } +#endif if (pWnd->pcls->CSF_flags & CSF_SERVERSIDEPROC) pWnd->state |= WNDS_SERVERSIDEWINDOWPROC; diff --git a/reactos/win32ss/user/user32/windows/class.c b/reactos/win32ss/user/user32/windows/class.c index 7ca74932532..fbfa9a6382e 100644 --- a/reactos/win32ss/user/user32/windows/class.c +++ b/reactos/win32ss/user/user32/windows/class.c @@ -712,7 +712,19 @@ IntGetClassLongA(PWND Wnd, PCLS Class, int nIndex) case GCW_ATOM: Ret = (ULONG_PTR)Class->atomClassName; break; +#ifdef NEW_CURSORICON + case GCLP_HCURSOR: + Ret = Class->spcur ? (ULONG_PTR)((PPROCMARKHEAD)DesktopPtrToUser(Class->spcur))->h : 0; + break; + case GCLP_HICON: + Ret = Class->spicn ? (ULONG_PTR)((PPROCMARKHEAD)DesktopPtrToUser(Class->spicn))->h : 0; + break; + + case GCLP_HICONSM: + Ret = Class->spicnSm ? (ULONG_PTR)((PPROCMARKHEAD)DesktopPtrToUser(Class->spicnSm))->h : 0; + break; +#else case GCLP_HCURSOR: /* FIXME - get handle from pointer to CURSOR object */ Ret = (ULONG_PTR)Class->hCursor; @@ -727,6 +739,7 @@ IntGetClassLongA(PWND Wnd, PCLS Class, int nIndex) /* FIXME - get handle from pointer to ICON object */ Ret = (ULONG_PTR)(Class->hIconSm ? Class->hIconSm : Class->hIconSmIntern); break; +#endif case GCLP_WNDPROC: Ret = IntGetClsWndProc(Wnd, Class, TRUE); @@ -790,6 +803,19 @@ IntGetClassLongW (PWND Wnd, PCLS Class, int nIndex) Ret = (ULONG_PTR)Class->atomClassName; break; +#ifdef NEW_CURSORICON + case GCLP_HCURSOR: + Ret = Class->spcur ? (ULONG_PTR)((PPROCMARKHEAD)DesktopPtrToUser(Class->spcur))->h : 0; + break; + + case GCLP_HICON: + Ret = Class->spicn ? (ULONG_PTR)((PPROCMARKHEAD)DesktopPtrToUser(Class->spicn))->h : 0; + break; + + case GCLP_HICONSM: + Ret = Class->spicnSm ? (ULONG_PTR)((PPROCMARKHEAD)DesktopPtrToUser(Class->spicnSm))->h : 0; + break; +#else case GCLP_HCURSOR: /* FIXME - get handle from pointer to CURSOR object */ Ret = (ULONG_PTR)Class->hCursor; @@ -804,6 +830,7 @@ IntGetClassLongW (PWND Wnd, PCLS Class, int nIndex) /* FIXME - get handle from pointer to ICON object */ Ret = (ULONG_PTR)(Class->hIconSm ? Class->hIconSm : Class->hIconSmIntern); break; +#endif case GCLP_WNDPROC: Ret = IntGetClsWndProc(Wnd, Class, FALSE);