win32ss/user/ntuser/scrollex.c

   1 /*
   2  *  COPYRIGHT:        See COPYING in the top level directory
   3  *  PROJECT:          ReactOS Win32k subsystem
   4  *  PURPOSE:          Window scrolling function
   5  *  FILE:             win32ss/user/ntuser/scrollex.c
   6  *  PROGRAMER:        Filip Navara (xnavara@volny.cz)
   7  */
   8
   9 #include <win32k.h>
  10
  11 DBG_DEFAULT_CHANNEL(UserPainting);
  12
  13 static
  14 HWND FASTCALL
  15 co_IntFixCaret(PWND Window, RECTL *lprc, UINT flags)
  16 {
  17    PTHRDCARETINFO CaretInfo;
  18    PTHREADINFO pti;
  19    PUSER_MESSAGE_QUEUE ThreadQueue;
  20    HWND hWndCaret;
  21    PWND WndCaret;
  22
  23    ASSERT_REFS_CO(Window);
  24
  25    pti = PsGetCurrentThreadWin32Thread();
  26    ThreadQueue = pti->MessageQueue;
  27    CaretInfo = &ThreadQueue->CaretInfo;
  28    hWndCaret = CaretInfo->hWnd;
  29
  30    WndCaret = ValidateHwndNoErr(hWndCaret);
  31
  32    // FIXME: Check for WndCaret can be NULL
  33    if (WndCaret == Window ||
  34          ((flags & SW_SCROLLCHILDREN) && IntIsChildWindow(Window, WndCaret)))
  35    {
  36       POINT pt, FromOffset, ToOffset;
  37       RECTL rcCaret;
  38
  39       pt.x = CaretInfo->Pos.x;
  40       pt.y = CaretInfo->Pos.y;
  41       IntGetClientOrigin(WndCaret, &FromOffset);
  42       IntGetClientOrigin(Window, &ToOffset);
  43       rcCaret.left = pt.x;
  44       rcCaret.top = pt.y;
  45       rcCaret.right = pt.x + CaretInfo->Size.cx;
  46       rcCaret.bottom = pt.y + CaretInfo->Size.cy;
  47       if (RECTL_bIntersectRect(lprc, lprc, &rcCaret))
  48       {
  49          co_UserHideCaret(0);
  50          lprc->left = pt.x;
  51          lprc->top = pt.y;
  52          return hWndCaret;
  53       }
  54    }
  55
  56    return 0;
  57 }
  58
  59 /*
  60     Old GetUpdateRgn, for scrolls, see above note.
  61  */
  62 INT FASTCALL
  63 co_IntGetUpdateRgn(PWND Window, PREGION Rgn, BOOL bErase)
  64 {
  65     int RegionType;
  66     RECTL Rect;
  67     PREGION UpdateRgn;
  68
  69     ASSERT_REFS_CO(Window);
  70
  71     if (bErase)
  72     {
  73        co_IntPaintWindows(Window, RDW_NOCHILDREN, FALSE);
  74     }
  75
  76     Window->state &= ~WNDS_UPDATEDIRTY;
  77
  78     if (Window->hrgnUpdate == NULL)
  79     {
  80         REGION_SetRectRgn(Rgn, 0, 0, 0, 0);
  81         return NULLREGION;
  82     }
  83
  84     UpdateRgn = REGION_LockRgn(Window->hrgnUpdate);
  85     if (!UpdateRgn)
  86        return ERROR;
  87
  88     Rect = Window->rcClient;
  89     IntIntersectWithParents(Window, &Rect);
  90     REGION_SetRectRgn(Rgn, Rect.left, Rect.top, Rect.right, Rect.bottom);
  91     RegionType = IntGdiCombineRgn(Rgn, Rgn, UpdateRgn, RGN_AND);
  92     REGION_bOffsetRgn(Rgn, -Window->rcClient.left, -Window->rcClient.top);
  93     REGION_UnlockRgn(UpdateRgn);
  94
  95     return RegionType;
  96 }
  97
  98 static
  99 INT FASTCALL
 100 UserScrollDC(
 101    HDC hDC,
 102    INT dx,
 103    INT dy,
 104    const RECTL *prcScroll,
 105    const RECTL *prcClip,
 106    HRGN hrgnUpdate,
 107    PREGION RgnUpdate,
 108    RECTL *prcUpdate)
 109 {
 110    PDC pDC;
 111    RECTL rcScroll, rcClip, rcSrc, rcDst;
 112    INT Result;
 113
 114    if (GdiGetClipBox(hDC, &rcClip) == ERROR)
 115    {
 116        ERR("GdiGetClipBox failed for HDC %p\n", hDC);
 117        return ERROR;
 118    }
 119
 120    rcScroll = rcClip;
 121    if (prcClip)
 122    {
 123       RECTL_bIntersectRect(&rcClip, &rcClip, prcClip);
 124    }
 125
 126    if (prcScroll)
 127    {
 128       rcScroll = *prcScroll;
 129       RECTL_bIntersectRect(&rcSrc, &rcClip, prcScroll);
 130    }
 131    else
 132    {
 133       rcSrc = rcClip;
 134    }
 135
 136    rcDst = rcSrc;
 137    RECTL_vOffsetRect(&rcDst, dx, dy);
 138    RECTL_bIntersectRect(&rcDst, &rcDst, &rcClip);
 139
 140    if (!NtGdiBitBlt( hDC,
 141                      rcDst.left,
 142                      rcDst.top,
 143                      rcDst.right - rcDst.left,
 144                      rcDst.bottom - rcDst.top,
 145                      hDC,
 146                      rcDst.left - dx,
 147                      rcDst.top - dy,
 148                      SRCCOPY,
 149                      0,
 150                      0))
 151    {
 152       return ERROR;
 153    }
 154
 155    /* Calculate the region that was invalidated by moving or
 156       could not be copied, because it was not visible */
 157    if (RgnUpdate || hrgnUpdate || prcUpdate)
 158    {
 159       PREGION RgnOwn, RgnTmp;
 160
 161       pDC = DC_LockDc(hDC);
 162       if (!pDC)
 163       {
 164          return ERROR;
 165       }
 166
 167        if (hrgnUpdate)
 168        {
 169            NT_ASSERT(RgnUpdate == NULL);
 170            RgnUpdate = REGION_LockRgn(hrgnUpdate);
 171            if (!RgnUpdate)
 172            {
 173                DC_UnlockDc(pDC);
 174                return ERROR;
 175            }
 176        }
 177
 178       /* Begin with the shifted and then clipped scroll rect */
 179       rcDst = rcScroll;
 180       RECTL_vOffsetRect(&rcDst, dx, dy);
 181       RECTL_bIntersectRect(&rcDst, &rcDst, &rcClip);
 182       if (RgnUpdate)
 183       {
 184          RgnOwn = RgnUpdate;
 185          REGION_SetRectRgn(RgnOwn, rcDst.left, rcDst.top, rcDst.right, rcDst.bottom);
 186       }
 187       else
 188       {
 189          RgnOwn = IntSysCreateRectpRgnIndirect(&rcDst);
 190       }
 191
 192       /* Add the source rect */
 193       RgnTmp = IntSysCreateRectpRgnIndirect(&rcSrc);
 194       IntGdiCombineRgn(RgnOwn, RgnOwn, RgnTmp, RGN_OR);
 195
 196       /* Substract the part of the dest that was visible in source */
 197       IntGdiCombineRgn(RgnTmp, RgnTmp, pDC->prgnVis, RGN_AND);
 198       REGION_bOffsetRgn(RgnTmp, dx, dy);
 199       Result = IntGdiCombineRgn(RgnOwn, RgnOwn, RgnTmp, RGN_DIFF);
 200
 201       /* DO NOT Unlock DC while messing with prgnVis! */
 202       DC_UnlockDc(pDC);
 203
 204       REGION_Delete(RgnTmp);
 205
 206       if (prcUpdate)
 207       {
 208          REGION_GetRgnBox(RgnOwn, prcUpdate);
 209       }
 210
 211       if (hrgnUpdate)
 212       {
 213          REGION_UnlockRgn(RgnUpdate);
 214       }
 215       else if (!RgnUpdate)
 216       {
 217          REGION_Delete(RgnOwn);
 218       }
 219    }
 220    else
 221       Result = NULLREGION;
 222
 223    return Result;
 224 }
 225
 226 DWORD
 227 FASTCALL
 228 IntScrollWindowEx(
 229    PWND Window,
 230    INT dx,
 231    INT dy,
 232    const RECT *prcScroll,
 233    const RECT *prcClip,
 234    HRGN hrgnUpdate,
 235    LPRECT prcUpdate,
 236    UINT flags)
 237 {
 238    INT Result;
 239    RECTL rcScroll, rcClip, rcCaret;
 240    PWND CaretWnd;
 241    HDC hDC;
 242    PREGION RgnUpdate = NULL, RgnTemp, RgnWinupd = NULL;
 243    HWND hwndCaret;
 244    DWORD dcxflags = 0;
 245    int rdw_flags;
 246    USER_REFERENCE_ENTRY CaretRef;
 247
 248    if (!Window || !IntIsWindowDrawable(Window))
 249    {
 250       return ERROR;
 251    }
 252
 253    IntGetClientRect(Window, &rcClip);
 254
 255    if (prcScroll)
 256       RECTL_bIntersectRect(&rcScroll, &rcClip, prcScroll);
 257    else
 258       rcScroll = rcClip;
 259
 260    if (prcClip)
 261       RECTL_bIntersectRect(&rcClip, &rcClip, prcClip);
 262
 263    if (rcClip.right <= rcClip.left || rcClip.bottom <= rcClip.top ||
 264          (dx == 0 && dy == 0))
 265    {
 266       return NULLREGION;
 267    }
 268
 269    /* We must use a copy of the region, as we can't hold an exclusive lock
 270     * on it while doing callouts to user-mode */
 271    RgnUpdate = IntSysCreateRectpRgn(0, 0, 0, 0);
 272    if(!RgnUpdate)
 273    {
 274        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
 275        return ERROR;
 276    }
 277
 278    if (hrgnUpdate)
 279    {
 280        RgnTemp = REGION_LockRgn(hrgnUpdate);
 281        if (!RgnTemp)
 282        {
 283            EngSetLastError(ERROR_INVALID_HANDLE);
 284            Result = ERROR;
 285            goto Cleanup;
 286        }
 287        IntGdiCombineRgn(RgnUpdate, RgnTemp, NULL, RGN_COPY);
 288        REGION_UnlockRgn(RgnTemp);
 289    }
 290
 291    /* ScrollWindow uses the window DC, ScrollWindowEx doesn't */
 292    if (flags & SW_SCROLLWNDDCE)
 293    {
 294       dcxflags = DCX_USESTYLE;
 295
 296       if (!(Window->pcls->style & (CS_OWNDC|CS_CLASSDC)))
 297          dcxflags |= DCX_CACHE; // AH??? wine~ If not Powned or with Class go Cheap!
 298
 299       if (flags & SW_SCROLLCHILDREN && Window->style & WS_CLIPCHILDREN)
 300          dcxflags |= DCX_CACHE|DCX_NOCLIPCHILDREN;
 301    }
 302    else
 303    {
 304        /* So in this case ScrollWindowEx uses Cache DC. */
 305        dcxflags = DCX_CACHE|DCX_USESTYLE;
 306        if (flags & SW_SCROLLCHILDREN) dcxflags |= DCX_NOCLIPCHILDREN;
 307    }
 308
 309    hDC = UserGetDCEx(Window, 0, dcxflags);
 310    if (!hDC)
 311    {
 312       /* FIXME: SetLastError? */
 313       Result = ERROR;
 314       goto Cleanup;
 315    }
 316
 317    rdw_flags = (flags & SW_ERASE) && (flags & SW_INVALIDATE) ? RDW_INVALIDATE | RDW_ERASE : RDW_INVALIDATE ;
 318
 319    rcCaret = rcScroll;
 320    hwndCaret = co_IntFixCaret(Window, &rcCaret, flags);
 321
 322    Result = UserScrollDC( hDC,
 323                           dx,
 324                           dy,
 325                           &rcScroll,
 326                           &rcClip,
 327                           NULL,
 328                           RgnUpdate,
 329                           prcUpdate);
 330
 331    UserReleaseDC(Window, hDC, FALSE);
 332
 333    /*
 334     * Take into account the fact that some damage may have occurred during
 335     * the scroll. Keep a copy in hrgnWinupd to be added to hrngUpdate at the end.
 336     */
 337
 338    RgnTemp = IntSysCreateRectpRgn(0, 0, 0, 0);
 339    if (!RgnTemp)
 340    {
 341        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
 342        Result = ERROR;
 343        goto Cleanup;
 344    }
 345
 346    if (co_IntGetUpdateRgn(Window, RgnTemp, FALSE) != NULLREGION)
 347    {
 348       PREGION RgnClip = IntSysCreateRectpRgnIndirect(&rcClip);
 349       if (RgnClip)
 350       {
 351           if (hrgnUpdate)
 352           {
 353              RgnWinupd = IntSysCreateRectpRgn(0, 0, 0, 0);
 354              // FIXME: What to do if RgnWinupd == NULL??
 355              IntGdiCombineRgn( RgnWinupd, RgnTemp, 0, RGN_COPY);
 356           }
 357
 358           REGION_bOffsetRgn(RgnTemp, dx, dy);
 359
 360           IntGdiCombineRgn(RgnTemp, RgnTemp, RgnClip, RGN_AND);
 361
 362           if (hrgnUpdate)
 363               IntGdiCombineRgn( RgnWinupd, RgnWinupd, RgnTemp, RGN_OR );
 364
 365           co_UserRedrawWindow(Window, NULL, RgnTemp, rdw_flags );
 366
 367           REGION_Delete(RgnClip);
 368       }
 369    }
 370    REGION_Delete(RgnTemp);
 371
 372    if (flags & SW_SCROLLCHILDREN)
 373    {
 374       PWND Child;
 375       RECTL rcChild;
 376       POINT ClientOrigin;
 377       USER_REFERENCE_ENTRY WndRef;
 378       RECTL rcDummy;
 379       LPARAM lParam;
 380
 381       IntGetClientOrigin(Window, &ClientOrigin);
 382
 383       for (Child = Window->spwndChild; Child; Child = Child->spwndNext)
 384       {
 385          rcChild = Child->rcWindow;
 386          RECTL_vOffsetRect(&rcChild, -ClientOrigin.x, -ClientOrigin.y);
 387
 388          if (!prcScroll || RECTL_bIntersectRect(&rcDummy, &rcChild, &rcScroll))
 389          {
 390             UserRefObjectCo(Child, &WndRef);
 391
 392             if (UserIsDesktopWindow(Window->spwndParent))
 393                lParam = MAKELONG(Child->rcClient.left, Child->rcClient.top);
 394             else
 395                lParam = MAKELONG(rcChild.left + dx, rcChild.top + dy);
 396
 397             /* wine sends WM_POSCHANGING, WM_POSCHANGED messages */
 398             /* windows sometimes a WM_MOVE */
 399             co_IntSendMessage(UserHMGetHandle(Child), WM_MOVE, 0, lParam);
 400
 401             UserDerefObjectCo(Child);
 402          }
 403       }
 404    }
 405
 406    if (flags & (SW_INVALIDATE | SW_ERASE))
 407    {
 408       co_UserRedrawWindow( Window,
 409                            NULL,
 410                            RgnUpdate,
 411                            rdw_flags |                                    /*    HACK    */
 412                           ((flags & SW_SCROLLCHILDREN) ? RDW_ALLCHILDREN : RDW_NOCHILDREN) );
 413    }
 414
 415    if (hwndCaret && (CaretWnd = UserGetWindowObject(hwndCaret)))
 416    {
 417       UserRefObjectCo(CaretWnd, &CaretRef);
 418
 419       co_IntSetCaretPos(rcCaret.left + dx, rcCaret.top + dy);
 420       co_UserShowCaret(CaretWnd);
 421
 422       UserDerefObjectCo(CaretWnd);
 423    }
 424
 425    if (hrgnUpdate && (Result != ERROR))
 426    {
 427        /* Give everything back to the caller */
 428        RgnTemp = REGION_LockRgn(hrgnUpdate);
 429        /* The handle should still be valid */
 430        ASSERT(RgnTemp);
 431        if (RgnWinupd)
 432            IntGdiCombineRgn(RgnTemp, RgnUpdate, RgnWinupd, RGN_OR);
 433        else
 434            IntGdiCombineRgn(RgnTemp, RgnUpdate, NULL, RGN_COPY);
 435        REGION_UnlockRgn(RgnTemp);
 436    }
 437
 438 Cleanup:
 439    if (RgnWinupd)
 440    {
 441        REGION_Delete(RgnWinupd);
 442    }
 443
 444    if (RgnUpdate)
 445    {
 446       REGION_Delete(RgnUpdate);
 447    }
 448
 449    return Result;
 450 }
 451
 452
 453 BOOL FASTCALL
 454 IntScrollWindow(PWND pWnd,
 455                 int dx,
 456                 int dy,
 457                 CONST RECT *lpRect,
 458                 CONST RECT *prcClip)
 459 {
 460    return IntScrollWindowEx( pWnd, dx, dy, lpRect, prcClip, 0, NULL,
 461                             (lpRect ? 0 : SW_SCROLLCHILDREN) | (SW_ERASE|SW_INVALIDATE|SW_SCROLLWNDDCE)) != ERROR;
 462 }
 463
 464 /*
 465  * NtUserScrollDC
 466  *
 467  * Status
 468  *    @implemented
 469  */
 470 BOOL APIENTRY
 471 NtUserScrollDC(
 472    HDC hDC,
 473    INT dx,
 474    INT dy,
 475    const RECT *prcUnsafeScroll,
 476    const RECT *prcUnsafeClip,
 477    HRGN hrgnUpdate,
 478    LPRECT prcUnsafeUpdate)
 479 {
 480    DECLARE_RETURN(DWORD);
 481    DWORD Result;
 482    NTSTATUS Status = STATUS_SUCCESS;
 483    RECTL rcScroll, rcClip, rcUpdate;
 484
 485    TRACE("Enter NtUserScrollDC\n");
 486    UserEnterExclusive();
 487
 488    _SEH2_TRY
 489    {
 490       if (prcUnsafeScroll)
 491       {
 492          ProbeForRead(prcUnsafeScroll, sizeof(*prcUnsafeScroll), 1);
 493          rcScroll = *prcUnsafeScroll;
 494       }
 495       if (prcUnsafeClip)
 496       {
 497          ProbeForRead(prcUnsafeClip, sizeof(*prcUnsafeClip), 1);
 498          rcClip = *prcUnsafeClip;
 499       }
 500       if (prcUnsafeUpdate)
 501       {
 502          ProbeForWrite(prcUnsafeUpdate, sizeof(*prcUnsafeUpdate), 1);
 503       }
 504    }
 505    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 506    {
 507       Status = _SEH2_GetExceptionCode();
 508    }
 509    _SEH2_END;
 510
 511    if (!NT_SUCCESS(Status))
 512    {
 513       SetLastNtError(Status);
 514       RETURN(FALSE);
 515    }
 516
 517    Result = UserScrollDC( hDC,
 518                           dx,
 519                           dy,
 520                           prcUnsafeScroll ? &rcScroll : NULL,
 521                           prcUnsafeClip   ? &rcClip   : NULL,
 522                           hrgnUpdate,
 523                           NULL,
 524                           prcUnsafeUpdate ? &rcUpdate : NULL);
 525    if(Result == ERROR)
 526    {
 527       /* FIXME: Only if hRgnUpdate is invalid we should SetLastError(ERROR_INVALID_HANDLE) */
 528       RETURN(FALSE);
 529    }
 530
 531    if (prcUnsafeUpdate)
 532    {
 533       _SEH2_TRY
 534       {
 535          *prcUnsafeUpdate = rcUpdate;
 536       }
 537       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 538       {
 539          Status = _SEH2_GetExceptionCode();
 540       }
 541       _SEH2_END;
 542
 543       if (!NT_SUCCESS(Status))
 544       {
 545          /* FIXME: SetLastError? */
 546          /* FIXME: correct? We have already scrolled! */
 547          RETURN(FALSE);
 548       }
 549    }
 550
 551    RETURN(TRUE);
 552
 553 CLEANUP:
 554    TRACE("Leave NtUserScrollDC, ret=%lu\n",_ret_);
 555    UserLeave();
 556    END_CLEANUP;
 557 }
 558
 559 /*
 560  * NtUserScrollWindowEx
 561  *
 562  * Status
 563  *    @implemented
 564  */
 565
 566 DWORD APIENTRY
 567 NtUserScrollWindowEx(
 568    HWND hWnd,
 569    INT dx,
 570    INT dy,
 571    const RECT *prcUnsafeScroll,
 572    const RECT *prcUnsafeClip,
 573    HRGN hrgnUpdate,
 574    LPRECT prcUnsafeUpdate,
 575    UINT flags)
 576 {
 577    DECLARE_RETURN(DWORD);
 578    INT Result;
 579    NTSTATUS Status = STATUS_SUCCESS;
 580    PWND Window = NULL;
 581    RECTL rcScroll, rcClip, rcUpdate;
 582    USER_REFERENCE_ENTRY Ref;
 583
 584    TRACE("Enter NtUserScrollWindowEx\n");
 585    UserEnterExclusive();
 586
 587    Window = UserGetWindowObject(hWnd);
 588    if (!Window || !IntIsWindowDrawable(Window))
 589    {
 590       Window = NULL; /* prevent deref at cleanup */
 591       RETURN(ERROR);
 592    }
 593    UserRefObjectCo(Window, &Ref);
 594
 595    _SEH2_TRY
 596    {
 597       if (prcUnsafeScroll)
 598       {
 599          ProbeForRead(prcUnsafeScroll, sizeof(*prcUnsafeScroll), 1);
 600          rcScroll = *prcUnsafeScroll;
 601       }
 602
 603       if (prcUnsafeClip)
 604       {
 605          ProbeForRead(prcUnsafeClip, sizeof(*prcUnsafeClip), 1);
 606          rcClip = *prcUnsafeClip;
 607       }
 608    }
 609    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 610    {
 611       Status = _SEH2_GetExceptionCode();
 612    }
 613    _SEH2_END;
 614
 615    if (!NT_SUCCESS(Status))
 616    {
 617       SetLastNtError(Status);
 618       RETURN(ERROR);
 619    }
 620
 621    Result = IntScrollWindowEx(Window,
 622                               dx, dy,
 623                               prcUnsafeScroll ? &rcScroll : NULL,
 624                               prcUnsafeClip   ? &rcClip   : NULL,
 625                               hrgnUpdate,
 626                               prcUnsafeUpdate ? &rcUpdate : NULL,
 627                               flags);
 628
 629    if (prcUnsafeUpdate)
 630    {
 631       _SEH2_TRY
 632       {
 633          /* Probe here, to not fail on invalid pointer before scrolling */
 634          ProbeForWrite(prcUnsafeUpdate, sizeof(*prcUnsafeUpdate), 1);
 635          *prcUnsafeUpdate = rcUpdate;
 636       }
 637       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 638       {
 639          Status = _SEH2_GetExceptionCode();
 640       }
 641       _SEH2_END;
 642
 643       if (!NT_SUCCESS(Status))
 644       {
 645          SetLastNtError(Status);
 646          RETURN(ERROR);
 647       }
 648    }
 649
 650    RETURN(Result);
 651
 652 CLEANUP:
 653    if (Window)
 654       UserDerefObjectCo(Window);
 655
 656    TRACE("Leave NtUserScrollWindowEx, ret=%lu\n",_ret_);
 657    UserLeave();
 658    END_CLEANUP;
 659 }
 660
 661 /* EOF */