| /* |
| * TTY window driver |
| * |
| * Copyright 1998,1999 Patrik Stridvall |
| */ |
| |
| #include "config.h" |
| |
| #include "gdi.h" |
| #include "ttydrv.h" |
| #include "region.h" |
| #include "win.h" |
| #include "winpos.h" |
| #include "debugtools.h" |
| |
| DEFAULT_DEBUG_CHANNEL(ttydrv); |
| |
| WND_DRIVER TTYDRV_WND_Driver = |
| { |
| TTYDRV_WND_ForceWindowRaise, |
| TTYDRV_WND_SetHostAttr |
| }; |
| |
| #define SWP_AGG_NOGEOMETRYCHANGE \ |
| (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE) |
| #define SWP_AGG_NOPOSCHANGE \ |
| (SWP_AGG_NOGEOMETRYCHANGE | SWP_NOZORDER) |
| #define SWP_AGG_STATUSFLAGS \ |
| (SWP_AGG_NOPOSCHANGE | SWP_FRAMECHANGED | SWP_HIDEWINDOW | SWP_SHOWWINDOW) |
| |
| /********************************************************************** |
| * CreateWindow (TTYDRV.@) |
| */ |
| BOOL TTYDRV_CreateWindow( HWND hwnd ) |
| { |
| #ifdef WINE_CURSES |
| WND *wndPtr = WIN_FindWndPtr( hwnd ); |
| WINDOW *window; |
| INT cellWidth=8, cellHeight=8; /* FIXME: Hardcoded */ |
| |
| TRACE("(%x)\n", hwnd); |
| |
| /* Only create top-level windows */ |
| if (wndPtr->dwStyle & WS_CHILD) |
| { |
| WIN_ReleaseWndPtr( wndPtr ); |
| return TRUE; |
| } |
| |
| if (!wndPtr->parent) /* desktop */ |
| window = root_window; |
| else |
| { |
| int x = wndPtr->rectWindow.left; |
| int y = wndPtr->rectWindow.top; |
| int cx = wndPtr->rectWindow.right - wndPtr->rectWindow.left; |
| int cy = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top; |
| |
| window = subwin( root_window, cy/cellHeight, cx/cellWidth, |
| y/cellHeight, x/cellWidth); |
| werase(window); |
| wrefresh(window); |
| } |
| wndPtr->pDriverData = window; |
| WIN_ReleaseWndPtr( wndPtr ); |
| #else /* defined(WINE_CURSES) */ |
| FIXME("(%x): stub\n", hwnd); |
| #endif /* defined(WINE_CURSES) */ |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * DestroyWindow (TTYDRV.@) |
| */ |
| BOOL TTYDRV_DestroyWindow( HWND hwnd ) |
| { |
| #ifdef WINE_CURSES |
| WND *wndPtr = WIN_FindWndPtr( hwnd ); |
| WINDOW *window = wndPtr->pDriverData; |
| |
| TRACE("(%x)\n", hwnd); |
| |
| if (window && window != root_window) delwin(window); |
| wndPtr->pDriverData = NULL; |
| WIN_ReleaseWndPtr( wndPtr ); |
| #else /* defined(WINE_CURSES) */ |
| FIXME("(%x): stub\n", hwnd); |
| #endif /* defined(WINE_CURSES) */ |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * TTYDRV_WND_ForceWindowRaise |
| */ |
| void TTYDRV_WND_ForceWindowRaise(WND *wndPtr) |
| { |
| FIXME("(%p): stub\n", wndPtr); |
| } |
| |
| /*********************************************************************** |
| * TTYDRV_WND_SetHostAttr |
| */ |
| BOOL TTYDRV_WND_SetHostAttr(WND *wndPtr, INT attr, INT value) |
| { |
| FIXME("(%p): stub\n", wndPtr); |
| |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * DCE_OffsetVisRgn |
| * |
| * Change region from DC-origin relative coordinates to screen coords. |
| */ |
| |
| static void DCE_OffsetVisRgn( HDC hDC, HRGN hVisRgn ) |
| { |
| DC *dc; |
| if (!(dc = DC_GetDCPtr( hDC ))) return; |
| |
| OffsetRgn( hVisRgn, dc->DCOrgX, dc->DCOrgY ); |
| |
| GDI_ReleaseObj( hDC ); |
| } |
| |
| |
| /*********************************************************************** |
| * DCE_GetVisRect |
| * |
| * Calculate the visible rectangle of a window (i.e. the client or |
| * window area clipped by the client area of all ancestors) in the |
| * corresponding coordinates. Return FALSE if the visible region is empty. |
| */ |
| static BOOL DCE_GetVisRect( WND *wndPtr, BOOL clientArea, RECT *lprect ) |
| { |
| *lprect = clientArea ? wndPtr->rectClient : wndPtr->rectWindow; |
| |
| if (wndPtr->dwStyle & WS_VISIBLE) |
| { |
| INT xoffset = lprect->left; |
| INT yoffset = lprect->top; |
| |
| while ((wndPtr = WIN_LockWndPtr(wndPtr->parent))) |
| { |
| if ( (wndPtr->dwStyle & (WS_ICONIC | WS_VISIBLE)) != WS_VISIBLE ) |
| { |
| WIN_ReleaseWndPtr(wndPtr); |
| goto fail; |
| } |
| |
| xoffset += wndPtr->rectClient.left; |
| yoffset += wndPtr->rectClient.top; |
| OffsetRect( lprect, wndPtr->rectClient.left, |
| wndPtr->rectClient.top ); |
| |
| if( (wndPtr->rectClient.left >= wndPtr->rectClient.right) || |
| (wndPtr->rectClient.top >= wndPtr->rectClient.bottom) || |
| (lprect->left >= wndPtr->rectClient.right) || |
| (lprect->right <= wndPtr->rectClient.left) || |
| (lprect->top >= wndPtr->rectClient.bottom) || |
| (lprect->bottom <= wndPtr->rectClient.top) ) |
| { |
| WIN_ReleaseWndPtr(wndPtr); |
| goto fail; |
| } |
| |
| lprect->left = max( lprect->left, wndPtr->rectClient.left ); |
| lprect->right = min( lprect->right, wndPtr->rectClient.right ); |
| lprect->top = max( lprect->top, wndPtr->rectClient.top ); |
| lprect->bottom = min( lprect->bottom, wndPtr->rectClient.bottom ); |
| |
| WIN_ReleaseWndPtr(wndPtr); |
| } |
| OffsetRect( lprect, -xoffset, -yoffset ); |
| return TRUE; |
| } |
| |
| fail: |
| SetRectEmpty( lprect ); |
| return FALSE; |
| } |
| |
| |
| /*********************************************************************** |
| * DCE_AddClipRects |
| * |
| * Go through the linked list of windows from pWndStart to pWndEnd, |
| * adding to the clip region the intersection of the target rectangle |
| * with an offset window rectangle. |
| */ |
| static BOOL DCE_AddClipRects( WND *pWndStart, WND *pWndEnd, |
| HRGN hrgnClip, LPRECT lpRect, int x, int y ) |
| { |
| RECT rect; |
| |
| for (WIN_LockWndPtr(pWndStart); (pWndStart && (pWndStart != pWndEnd)); WIN_UpdateWndPtr(&pWndStart,pWndStart->next)) |
| { |
| if( !(pWndStart->dwStyle & WS_VISIBLE) ) continue; |
| |
| rect.left = pWndStart->rectWindow.left + x; |
| rect.top = pWndStart->rectWindow.top + y; |
| rect.right = pWndStart->rectWindow.right + x; |
| rect.bottom = pWndStart->rectWindow.bottom + y; |
| |
| if( IntersectRect( &rect, &rect, lpRect )) |
| { |
| if(!REGION_UnionRectWithRgn( hrgnClip, &rect )) break; |
| } |
| } |
| WIN_ReleaseWndPtr(pWndStart); |
| return (pWndStart == pWndEnd); |
| } |
| |
| |
| /*********************************************************************** |
| * DCE_GetVisRgn |
| * |
| * Return the visible region of a window, i.e. the client or window area |
| * clipped by the client area of all ancestors, and then optionally |
| * by siblings and children. |
| */ |
| static HRGN DCE_GetVisRgn( HWND hwnd, WORD flags, HWND hwndChild, WORD cflags ) |
| { |
| HRGN hrgnVis = 0; |
| RECT rect; |
| WND *wndPtr = WIN_FindWndPtr( hwnd ); |
| WND *childWnd = WIN_FindWndPtr( hwndChild ); |
| |
| /* Get visible rectangle and create a region with it. */ |
| |
| if (wndPtr && DCE_GetVisRect(wndPtr, !(flags & DCX_WINDOW), &rect)) |
| { |
| if((hrgnVis = CreateRectRgnIndirect( &rect ))) |
| { |
| HRGN hrgnClip = CreateRectRgn( 0, 0, 0, 0 ); |
| INT xoffset, yoffset; |
| |
| if( hrgnClip ) |
| { |
| /* Compute obscured region for the visible rectangle by |
| * clipping children, siblings, and ancestors. Note that |
| * DCE_GetVisRect() returns a rectangle either in client |
| * or in window coordinates (for DCX_WINDOW request). */ |
| |
| if( (flags & DCX_CLIPCHILDREN) && wndPtr->child ) |
| { |
| if( flags & DCX_WINDOW ) |
| { |
| /* adjust offsets since child window rectangles are |
| * in client coordinates */ |
| |
| xoffset = wndPtr->rectClient.left - wndPtr->rectWindow.left; |
| yoffset = wndPtr->rectClient.top - wndPtr->rectWindow.top; |
| } |
| else |
| xoffset = yoffset = 0; |
| |
| DCE_AddClipRects( wndPtr->child, NULL, hrgnClip, &rect, xoffset, yoffset ); |
| } |
| |
| /* We may need to clip children of child window, if a window with PARENTDC |
| * class style and CLIPCHILDREN window style (like in Free Agent 16 |
| * preference dialogs) gets here, we take the region for the parent window |
| * but apparently still need to clip the children of the child window... */ |
| |
| if( (cflags & DCX_CLIPCHILDREN) && childWnd && childWnd->child ) |
| { |
| if( flags & DCX_WINDOW ) |
| { |
| /* adjust offsets since child window rectangles are |
| * in client coordinates */ |
| |
| xoffset = wndPtr->rectClient.left - wndPtr->rectWindow.left; |
| yoffset = wndPtr->rectClient.top - wndPtr->rectWindow.top; |
| } |
| else |
| xoffset = yoffset = 0; |
| |
| /* client coordinates of child window */ |
| xoffset += childWnd->rectClient.left; |
| yoffset += childWnd->rectClient.top; |
| |
| DCE_AddClipRects( childWnd->child, NULL, hrgnClip, |
| &rect, xoffset, yoffset ); |
| } |
| |
| /* sibling window rectangles are in client |
| * coordinates of the parent window */ |
| |
| if (flags & DCX_WINDOW) |
| { |
| xoffset = -wndPtr->rectWindow.left; |
| yoffset = -wndPtr->rectWindow.top; |
| } |
| else |
| { |
| xoffset = -wndPtr->rectClient.left; |
| yoffset = -wndPtr->rectClient.top; |
| } |
| |
| if (flags & DCX_CLIPSIBLINGS && wndPtr->parent ) |
| DCE_AddClipRects( wndPtr->parent->child, |
| wndPtr, hrgnClip, &rect, xoffset, yoffset ); |
| |
| /* Clip siblings of all ancestors that have the |
| * WS_CLIPSIBLINGS style |
| */ |
| |
| while (wndPtr->parent) |
| { |
| WIN_UpdateWndPtr(&wndPtr,wndPtr->parent); |
| xoffset -= wndPtr->rectClient.left; |
| yoffset -= wndPtr->rectClient.top; |
| if(wndPtr->dwStyle & WS_CLIPSIBLINGS && wndPtr->parent) |
| { |
| DCE_AddClipRects( wndPtr->parent->child, wndPtr, |
| hrgnClip, &rect, xoffset, yoffset ); |
| } |
| } |
| |
| /* Now once we've got a jumbo clip region we have |
| * to substract it from the visible rectangle. |
| */ |
| CombineRgn( hrgnVis, hrgnVis, hrgnClip, RGN_DIFF ); |
| DeleteObject( hrgnClip ); |
| } |
| else |
| { |
| DeleteObject( hrgnVis ); |
| hrgnVis = 0; |
| } |
| } |
| } |
| else |
| hrgnVis = CreateRectRgn(0, 0, 0, 0); /* empty */ |
| WIN_ReleaseWndPtr(wndPtr); |
| WIN_ReleaseWndPtr(childWnd); |
| return hrgnVis; |
| } |
| |
| |
| /*********************************************************************** |
| * GetDC (TTYDRV.@) |
| * |
| * Set the drawable, origin and dimensions for the DC associated to |
| * a given window. |
| */ |
| BOOL TTYDRV_GetDC( HWND hwnd, HDC hdc, HRGN hrgn, DWORD flags ) |
| { |
| WND *wndPtr = WIN_FindWndPtr(hwnd); |
| DC *dc; |
| BOOL updateVisRgn; |
| HRGN hrgnVisible = 0; |
| |
| if (!wndPtr) return FALSE; |
| |
| if (!(dc = DC_GetDCPtr( hdc ))) |
| { |
| WIN_ReleaseWndPtr( wndPtr ); |
| return FALSE; |
| } |
| |
| if(flags & DCX_WINDOW) |
| { |
| dc->DCOrgX = wndPtr->rectWindow.left; |
| dc->DCOrgY = wndPtr->rectWindow.top; |
| } |
| else |
| { |
| dc->DCOrgX = wndPtr->rectClient.left; |
| dc->DCOrgY = wndPtr->rectClient.top; |
| } |
| updateVisRgn = (dc->flags & DC_DIRTY) != 0; |
| GDI_ReleaseObj( hdc ); |
| |
| if (updateVisRgn) |
| { |
| if (flags & DCX_PARENTCLIP) |
| { |
| WND *parentPtr = WIN_LockWndPtr(wndPtr->parent); |
| |
| if( wndPtr->dwStyle & WS_VISIBLE && !(parentPtr->dwStyle & WS_MINIMIZE) ) |
| { |
| DWORD dcxFlags; |
| |
| if( parentPtr->dwStyle & WS_CLIPSIBLINGS ) |
| dcxFlags = DCX_CLIPSIBLINGS | (flags & ~(DCX_CLIPCHILDREN | DCX_WINDOW)); |
| else |
| dcxFlags = flags & ~(DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | DCX_WINDOW); |
| |
| hrgnVisible = DCE_GetVisRgn( parentPtr->hwndSelf, dcxFlags, |
| wndPtr->hwndSelf, flags ); |
| if( flags & DCX_WINDOW ) |
| OffsetRgn( hrgnVisible, -wndPtr->rectWindow.left, |
| -wndPtr->rectWindow.top ); |
| else |
| OffsetRgn( hrgnVisible, -wndPtr->rectClient.left, |
| -wndPtr->rectClient.top ); |
| DCE_OffsetVisRgn( hdc, hrgnVisible ); |
| } |
| else |
| hrgnVisible = CreateRectRgn( 0, 0, 0, 0 ); |
| WIN_ReleaseWndPtr(parentPtr); |
| } |
| else |
| { |
| hrgnVisible = DCE_GetVisRgn( hwnd, flags, 0, 0 ); |
| DCE_OffsetVisRgn( hdc, hrgnVisible ); |
| } |
| SelectVisRgn16( hdc, hrgnVisible ); |
| } |
| |
| /* apply additional region operation (if any) */ |
| |
| if( flags & (DCX_EXCLUDERGN | DCX_INTERSECTRGN) ) |
| { |
| if( !hrgnVisible ) hrgnVisible = CreateRectRgn( 0, 0, 0, 0 ); |
| |
| TRACE("\tsaved VisRgn, clipRgn = %04x\n", hrgn); |
| |
| SaveVisRgn16( hdc ); |
| CombineRgn( hrgnVisible, hrgn, 0, RGN_COPY ); |
| DCE_OffsetVisRgn( hdc, hrgnVisible ); |
| CombineRgn( hrgnVisible, InquireVisRgn16( hdc ), hrgnVisible, |
| (flags & DCX_INTERSECTRGN) ? RGN_AND : RGN_DIFF ); |
| SelectVisRgn16( hdc, hrgnVisible ); |
| } |
| |
| if (hrgnVisible) DeleteObject( hrgnVisible ); |
| |
| WIN_ReleaseWndPtr( wndPtr ); |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * SetWindowPos (TTYDRV.@) |
| */ |
| BOOL TTYDRV_SetWindowPos( WINDOWPOS *winpos ) |
| { |
| WND *wndPtr; |
| RECT newWindowRect, newClientRect; |
| BOOL retvalue; |
| HWND hwndActive = GetForegroundWindow(); |
| |
| TRACE( "hwnd %04x, swp (%i,%i)-(%i,%i) flags %08x\n", |
| winpos->hwnd, winpos->x, winpos->y, |
| winpos->x + winpos->cx, winpos->y + winpos->cy, winpos->flags); |
| |
| /* ------------------------------------------------------------------------ CHECKS */ |
| |
| /* Check window handle */ |
| |
| if (winpos->hwnd == GetDesktopWindow()) return FALSE; |
| if (!(wndPtr = WIN_FindWndPtr( winpos->hwnd ))) return FALSE; |
| |
| TRACE("\tcurrent (%i,%i)-(%i,%i), style %08x\n", |
| wndPtr->rectWindow.left, wndPtr->rectWindow.top, |
| wndPtr->rectWindow.right, wndPtr->rectWindow.bottom, (unsigned)wndPtr->dwStyle ); |
| |
| /* Fix redundant flags */ |
| |
| if(wndPtr->dwStyle & WS_VISIBLE) |
| winpos->flags &= ~SWP_SHOWWINDOW; |
| else |
| { |
| if (!(winpos->flags & SWP_SHOWWINDOW)) winpos->flags |= SWP_NOREDRAW; |
| winpos->flags &= ~SWP_HIDEWINDOW; |
| } |
| |
| if ( winpos->cx < 0 ) winpos->cx = 0; |
| if ( winpos->cy < 0 ) winpos->cy = 0; |
| |
| if ((wndPtr->rectWindow.right - wndPtr->rectWindow.left == winpos->cx) && |
| (wndPtr->rectWindow.bottom - wndPtr->rectWindow.top == winpos->cy)) |
| winpos->flags |= SWP_NOSIZE; /* Already the right size */ |
| |
| if ((wndPtr->rectWindow.left == winpos->x) && (wndPtr->rectWindow.top == winpos->y)) |
| winpos->flags |= SWP_NOMOVE; /* Already the right position */ |
| |
| if (winpos->hwnd == hwndActive) |
| winpos->flags |= SWP_NOACTIVATE; /* Already active */ |
| else if ( (wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) != WS_CHILD ) |
| { |
| if(!(winpos->flags & SWP_NOACTIVATE)) /* Bring to the top when activating */ |
| { |
| winpos->flags &= ~SWP_NOZORDER; |
| winpos->hwndInsertAfter = HWND_TOP; |
| goto Pos; |
| } |
| } |
| |
| /* Check hwndInsertAfter */ |
| |
| /* FIXME: TOPMOST not supported yet */ |
| if ((winpos->hwndInsertAfter == HWND_TOPMOST) || |
| (winpos->hwndInsertAfter == HWND_NOTOPMOST)) winpos->hwndInsertAfter = HWND_TOP; |
| |
| /* hwndInsertAfter must be a sibling of the window */ |
| if ((winpos->hwndInsertAfter != HWND_TOP) && (winpos->hwndInsertAfter != HWND_BOTTOM)) |
| { |
| WND* wnd = WIN_FindWndPtr(winpos->hwndInsertAfter); |
| |
| if( wnd ) { |
| if( wnd->parent != wndPtr->parent ) |
| { |
| retvalue = FALSE; |
| WIN_ReleaseWndPtr(wnd); |
| goto END; |
| } |
| /* don't need to change the Zorder of hwnd if it's already inserted |
| * after hwndInsertAfter or when inserting hwnd after itself. |
| */ |
| if(( wnd->next == wndPtr ) || (winpos->hwnd == winpos->hwndInsertAfter)) |
| winpos->flags |= SWP_NOZORDER; |
| } |
| WIN_ReleaseWndPtr(wnd); |
| } |
| |
| Pos: /* ------------------------------------------------------------------------ MAIN part */ |
| |
| /* Send WM_WINDOWPOSCHANGING message */ |
| |
| if (!(winpos->flags & SWP_NOSENDCHANGING)) |
| SendMessageA( wndPtr->hwndSelf, WM_WINDOWPOSCHANGING, 0, (LPARAM)winpos ); |
| |
| /* Calculate new position and size */ |
| |
| newWindowRect = wndPtr->rectWindow; |
| newClientRect = (wndPtr->dwStyle & WS_MINIMIZE) ? wndPtr->rectWindow |
| : wndPtr->rectClient; |
| |
| if (!(winpos->flags & SWP_NOSIZE)) |
| { |
| newWindowRect.right = newWindowRect.left + winpos->cx; |
| newWindowRect.bottom = newWindowRect.top + winpos->cy; |
| } |
| if (!(winpos->flags & SWP_NOMOVE)) |
| { |
| newWindowRect.left = winpos->x; |
| newWindowRect.top = winpos->y; |
| newWindowRect.right += winpos->x - wndPtr->rectWindow.left; |
| newWindowRect.bottom += winpos->y - wndPtr->rectWindow.top; |
| |
| OffsetRect( &newClientRect, winpos->x - wndPtr->rectWindow.left, |
| winpos->y - wndPtr->rectWindow.top ); |
| } |
| |
| if( winpos->hwndInsertAfter == HWND_TOP ) |
| winpos->flags |= ( wndPtr->parent->child == wndPtr)? SWP_NOZORDER: 0; |
| else |
| if( winpos->hwndInsertAfter == HWND_BOTTOM ) |
| winpos->flags |= ( wndPtr->next )? 0: SWP_NOZORDER; |
| else |
| if( !(winpos->flags & SWP_NOZORDER) ) |
| if( GetWindow(winpos->hwndInsertAfter, GW_HWNDNEXT) == wndPtr->hwndSelf ) |
| winpos->flags |= SWP_NOZORDER; |
| |
| /* Common operations */ |
| |
| /* Send WM_NCCALCSIZE message to get new client area */ |
| if( (winpos->flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE ) |
| { |
| WINPOS_SendNCCalcSize( winpos->hwnd, TRUE, &newWindowRect, |
| &wndPtr->rectWindow, &wndPtr->rectClient, |
| winpos, &newClientRect ); |
| } |
| |
| if(!(winpos->flags & SWP_NOZORDER) && winpos->hwnd != winpos->hwndInsertAfter) |
| { |
| if ( WIN_UnlinkWindow( winpos->hwnd ) ) |
| WIN_LinkWindow( winpos->hwnd, winpos->hwndInsertAfter ); |
| } |
| |
| /* FIXME: actually do something with WVR_VALIDRECTS */ |
| |
| wndPtr->rectWindow = newWindowRect; |
| wndPtr->rectClient = newClientRect; |
| |
| if( winpos->flags & SWP_SHOWWINDOW ) |
| { |
| wndPtr->dwStyle |= WS_VISIBLE; |
| } |
| else if( winpos->flags & SWP_HIDEWINDOW ) |
| { |
| wndPtr->dwStyle &= ~WS_VISIBLE; |
| } |
| |
| /* ------------------------------------------------------------------------ FINAL */ |
| |
| /* repaint invalidated region (if any) |
| * |
| * FIXME: if SWP_NOACTIVATE is not set then set invalid regions here without any painting |
| * and force update after ChangeActiveWindow() to avoid painting frames twice. |
| */ |
| |
| if( !(winpos->flags & SWP_NOREDRAW) ) |
| { |
| RedrawWindow( wndPtr->parent->hwndSelf, NULL, 0, |
| RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN ); |
| if (wndPtr->parent->hwndSelf == GetDesktopWindow() || |
| wndPtr->parent->parent->hwndSelf == GetDesktopWindow()) |
| { |
| RedrawWindow( wndPtr->parent->hwndSelf, NULL, 0, |
| RDW_ERASENOW | RDW_NOCHILDREN ); |
| } |
| } |
| |
| if (!(winpos->flags & SWP_NOACTIVATE)) |
| WINPOS_ChangeActiveWindow( winpos->hwnd, FALSE ); |
| |
| /* And last, send the WM_WINDOWPOSCHANGED message */ |
| |
| TRACE("\tstatus flags = %04x\n", winpos->flags & SWP_AGG_STATUSFLAGS); |
| |
| if ((((winpos->flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE) && |
| !(winpos->flags & SWP_NOSENDCHANGING)) ) |
| SendMessageA( winpos->hwnd, WM_WINDOWPOSCHANGED, 0, (LPARAM)winpos ); |
| |
| retvalue = TRUE; |
| END: |
| WIN_ReleaseWndPtr(wndPtr); |
| return retvalue; |
| } |
