windows/scroll.c

   1 /*
   2  * Scroll windows and DCs
   3  *
   4  * Copyright  David W. Metcalfe, 1993
   5  *            Alex Korobka       1995,1996
   6  *
   7  *
   8  */
   9
  10 #include <stdlib.h>
  11 #include "windows.h"
  12 #include "class.h"
  13 #include "win.h"
  14 #include "gdi.h"
  15 #include "dce.h"
  16 #include "region.h"
  17 #include "graphics.h"
  18 #include "sysmetrics.h"
  19 #include "debug.h"
  20
  21 extern HWND32 CARET_GetHwnd();                  /* windows/caret.c */
  22 extern void   CARET_GetRect(LPRECT32);
  23 extern void CLIPPING_UpdateGCRegion(DC* );      /* objects/clipping.c */
  24
  25 /*************************************************************************
  26  *             ScrollWindow16   (USER.61)
  27  */
  28 void WINAPI ScrollWindow16(HWND16 hwnd, INT16 dx, INT16 dy, const RECT16 *rect,
  29                            const RECT16 *clipRect )
  30 {
  31     RECT32 rect32, clipRect32;
  32
  33     if (rect) CONV_RECT16TO32( rect, &rect32 );
  34     if (clipRect) CONV_RECT16TO32( clipRect, &clipRect32 );
  35     ScrollWindow32( hwnd, dx, dy, rect ? &rect32 : NULL,
  36                     clipRect ? &clipRect32 : NULL );
  37 }
  38
  39 /*************************************************************************
  40  *             ScrollWindow32   (USER32.449)
  41  *
  42  * FIXME: verify clipping region calculations
  43  */
  44 BOOL32 WINAPI ScrollWindow32( HWND32 hwnd, INT32 dx, INT32 dy,
  45                               const RECT32 *rect, const RECT32 *clipRect )
  46 {
  47     HDC32       hdc;
  48     HRGN32      hrgnUpdate,hrgnClip;
  49     RECT32      rc, cliprc;
  50     HWND32      hCaretWnd = CARET_GetHwnd();
  51     WND*        wndScroll = WIN_FindWndPtr( hwnd );
  52
  53     TRACE(scroll,"hwnd=%04x, dx=%d, dy=%d, lpRect =%p clipRect=%i,%i,%i,%i\n",
  54                    hwnd, dx, dy, rect,
  55                    clipRect ? clipRect->left : 0,
  56                    clipRect ? clipRect->top : 0,
  57                    clipRect ? clipRect->right : 0,
  58                    clipRect ? clipRect->bottom : 0 );
  59
  60     if ( !wndScroll || !WIN_IsWindowDrawable( wndScroll, TRUE ) ) return TRUE;
  61
  62     if ( !rect ) /* do not clip children */
  63        {
  64           GetClientRect32(hwnd, &rc);
  65           hrgnClip = CreateRectRgnIndirect32( &rc );
  66
  67           if ((hCaretWnd == hwnd) || IsChild32(hwnd,hCaretWnd))
  68               HideCaret32(hCaretWnd);
  69           else hCaretWnd = 0;
  70
  71           hdc = GetDCEx32(hwnd, hrgnClip, DCX_CACHE | DCX_CLIPSIBLINGS);
  72           DeleteObject32( hrgnClip );
  73        }
  74     else        /* clip children */
  75        {
  76           CopyRect32(&rc, rect);
  77
  78           if (hCaretWnd == hwnd) HideCaret32(hCaretWnd);
  79           else hCaretWnd = 0;
  80
  81           hdc = GetDCEx32( hwnd, 0, DCX_CACHE | DCX_USESTYLE );
  82        }
  83
  84     if (clipRect == NULL)
  85         GetClientRect32(hwnd, &cliprc);
  86     else
  87         CopyRect32(&cliprc, clipRect);
  88
  89     hrgnUpdate = CreateRectRgn32( 0, 0, 0, 0 );
  90     ScrollDC32( hdc, dx, dy, &rc, &cliprc, hrgnUpdate, NULL );
  91     ReleaseDC32(hwnd, hdc);
  92
  93     if( !rect )         /* move child windows and update region */
  94     {
  95       WND*      wndPtr;
  96
  97       if( wndScroll->hrgnUpdate > 1 )
  98         OffsetRgn32( wndScroll->hrgnUpdate, dx, dy );
  99
 100       for (wndPtr = wndScroll->child; wndPtr; wndPtr = wndPtr->next)
 101         SetWindowPos32(wndPtr->hwndSelf, 0, wndPtr->rectWindow.left + dx,
 102                        wndPtr->rectWindow.top  + dy, 0,0, SWP_NOZORDER |
 103                        SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOREDRAW |
 104                        SWP_DEFERERASE );
 105     }
 106
 107     PAINT_RedrawWindow( hwnd, NULL, hrgnUpdate, RDW_ALLCHILDREN |
 108                  RDW_INVALIDATE | RDW_ERASE | RDW_ERASENOW, RDW_C_USEHRGN );
 109
 110     DeleteObject32( hrgnUpdate );
 111     if( hCaretWnd )
 112     {
 113         POINT32 pt;
 114         GetCaretPos32(&pt);
 115         pt.x += dx; pt.y += dy;
 116         SetCaretPos32(pt.x, pt.y);
 117         ShowCaret32(hCaretWnd);
 118     }
 119     return TRUE;
 120 }
 121
 122
 123 /*************************************************************************
 124  *             ScrollDC16   (USER.221)
 125  */
 126 BOOL16 WINAPI ScrollDC16( HDC16 hdc, INT16 dx, INT16 dy, const RECT16 *rect,
 127                           const RECT16 *cliprc, HRGN16 hrgnUpdate,
 128                           LPRECT16 rcUpdate )
 129 {
 130     RECT32 rect32, clipRect32, rcUpdate32;
 131     BOOL16 ret;
 132
 133     if (rect) CONV_RECT16TO32( rect, &rect32 );
 134     if (cliprc) CONV_RECT16TO32( cliprc, &clipRect32 );
 135     ret = ScrollDC32( hdc, dx, dy, rect ? &rect32 : NULL,
 136                       cliprc ? &clipRect32 : NULL, hrgnUpdate, &rcUpdate32 );
 137     if (rcUpdate) CONV_RECT32TO16( &rcUpdate32, rcUpdate );
 138     return ret;
 139 }
 140
 141
 142 /*************************************************************************
 143  *             ScrollDC32   (USER32.448)
 144  *
 145  * Both 'rc' and 'prLClip' are in logical units but update info is
 146  * returned in device coordinates.
 147  */
 148 BOOL32 WINAPI ScrollDC32( HDC32 hdc, INT32 dx, INT32 dy, const RECT32 *rc,
 149                           const RECT32 *prLClip, HRGN32 hrgnUpdate,
 150                           LPRECT32 rcUpdate )
 151 {
 152     RECT32 rDClip, rLClip;
 153     HRGN32 hrgnClip = 0;
 154     HRGN32 hrgnScrollClip = 0;
 155     POINT32 src, dest;
 156     INT32  ldx, ldy;
 157     DC *dc = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
 158
 159     TRACE(scroll,"%04x %d,%d hrgnUpdate=%04x rcUpdate = %p cliprc = (%d,%d-%d,%d), rc=(%d,%d-%d,%d)\n",
 160                    (HDC16)hdc, dx, dy, hrgnUpdate, rcUpdate,
 161                    prLClip ? prLClip->left : 0, prLClip ? prLClip->top : 0, prLClip ? prLClip->right : 0, prLClip ? prLClip->bottom : 0,
 162                    rc ? rc->left : 0, rc ? rc->top : 0, rc ? rc->right : 0, rc ? rc->bottom : 0 );
 163
 164     if ( !dc || !hdc ) return FALSE;
 165
 166 /*
 167     TRACE(scroll,"\t[wndOrgX=%i, wndExtX=%i, vportOrgX=%i, vportExtX=%i]\n",
 168           dc->wndOrgX, dc->wndExtX, dc->vportOrgX, dc->vportExtX );
 169     TRACE(scroll,"\t[wndOrgY=%i, wndExtY=%i, vportOrgY=%i, vportExtY=%i]\n",
 170           dc->wndOrgY, dc->wndExtY, dc->vportOrgY, dc->vportExtY );
 171 */
 172
 173     /* compute device clipping region */
 174
 175     if ( rc )
 176     {
 177         rLClip = *rc;
 178         rDClip.left = XLPTODP(dc, rc->left); rDClip.right = XLPTODP(dc, rc->right);
 179         rDClip.top = YLPTODP(dc, rc->top); rDClip.bottom = YLPTODP(dc, rc->bottom);
 180     }
 181     else /* maybe we should just return FALSE? */
 182     {
 183         GetClipBox32( hdc, &rDClip );
 184         rLClip.left = XDPTOLP(dc, rDClip.left); rLClip.right = XDPTOLP(dc, rDClip.right);
 185         rLClip.top = YDPTOLP(dc, rDClip.top); rLClip.bottom = YDPTOLP(dc, rDClip.bottom);
 186     }
 187
 188     if (prLClip)
 189     {
 190         RECT32 r;
 191
 192         r.left = XLPTODP(dc, prLClip->left); r.right = XLPTODP(dc, prLClip->right);
 193         r.top = YLPTODP(dc, prLClip->top); r.bottom = YLPTODP(dc, prLClip->bottom);
 194         IntersectRect32(&rLClip,&rLClip,prLClip);
 195         IntersectRect32(&rDClip,&rDClip,&r);
 196     }
 197
 198     if( rDClip.left >= rDClip.right || rDClip.top >= rDClip.bottom )
 199         return FALSE;
 200
 201     hrgnClip = GetClipRgn16(hdc);
 202     hrgnScrollClip = CreateRectRgnIndirect32(&rDClip);
 203
 204     if( hrgnClip )
 205       {
 206         /* change device clipping region directly */
 207
 208         CombineRgn32( hrgnScrollClip, hrgnClip, 0, RGN_COPY );
 209         SetRectRgn32( hrgnClip, rDClip.left, rDClip.top,
 210                       rDClip.right, rDClip.bottom );
 211
 212         CLIPPING_UpdateGCRegion( dc );
 213       }
 214     else
 215         SelectClipRgn32( hdc, hrgnScrollClip );
 216
 217     /* translate coordinates */
 218
 219     ldx = dx * dc->wndExtX / dc->vportExtX;
 220     ldy = dy * dc->wndExtY / dc->vportExtY;
 221
 222     if (dx > 0)
 223         dest.x = (src.x = rLClip.left) + ldx;
 224     else
 225         src.x = (dest.x = rLClip.left) - ldx;
 226
 227     if (dy > 0)
 228         dest.y = (src.y = rLClip.top) + ldy;
 229     else
 230         src.y = (dest.y = rLClip.top) - ldy;
 231
 232     /* copy bits */
 233
 234     if( rDClip.right - rDClip.left > dx &&
 235         rDClip.bottom - rDClip.top > dy )
 236     {
 237         ldx = rLClip.right - rLClip.left - ldx;
 238         ldy = rLClip.bottom - rLClip.top - ldy;
 239
 240         if (!BitBlt32( hdc, dest.x, dest.y, ldx, ldy,
 241                        hdc, src.x, src.y, SRCCOPY))
 242             return FALSE;
 243     }
 244
 245     /* restore clipping region */
 246
 247     if( hrgnClip )
 248     {
 249         CombineRgn32( hrgnClip, hrgnScrollClip, 0, RGN_COPY );
 250         CLIPPING_UpdateGCRegion( dc );
 251         SetRectRgn32( hrgnScrollClip, rDClip.left, rDClip.top,
 252                       rDClip.right, rDClip.bottom );
 253     }
 254     else
 255         SelectClipRgn32( hdc, 0 );
 256
 257     /* compute update areas */
 258
 259     if (hrgnUpdate || rcUpdate)
 260     {
 261         HRGN32 hrgn = (hrgnUpdate) ? hrgnUpdate : CreateRectRgn32( 0,0,0,0 );
 262
 263         if( dc->w.hVisRgn )
 264         {
 265           CombineRgn32( hrgn, dc->w.hVisRgn, hrgnScrollClip, RGN_AND );
 266           OffsetRgn32( hrgn, dx, dy );
 267           CombineRgn32( hrgn, dc->w.hVisRgn, hrgn, RGN_DIFF );
 268           CombineRgn32( hrgn, hrgn, hrgnScrollClip, RGN_AND );
 269         }
 270         else
 271         {
 272           RECT32 rect;
 273
 274           rect = rDClip;                                /* vertical band */
 275           if (dx > 0) rect.right = rect.left + dx;
 276           else if (dx < 0) rect.left = rect.right + dx;
 277           else SetRectEmpty32( &rect );
 278           SetRectRgn32( hrgn, rect.left, rect.top, rect.right, rect.bottom );
 279
 280           rect = rDClip;                                /* horizontal band */
 281           if (dy > 0) rect.bottom = rect.top + dy;
 282           else if (dy < 0) rect.top = rect.bottom + dy;
 283           else SetRectEmpty32( &rect );
 284
 285           REGION_UnionRectWithRgn( hrgn, &rect );
 286         }
 287
 288         if (rcUpdate) GetRgnBox32( hrgn, rcUpdate );
 289         if (!hrgnUpdate) DeleteObject32( hrgn );
 290     }
 291
 292     DeleteObject32( hrgnScrollClip );
 293     return TRUE;
 294 }
 295
 296
 297 /*************************************************************************
 298  *             ScrollWindowEx16   (USER.319)
 299  */
 300 INT16 WINAPI ScrollWindowEx16( HWND16 hwnd, INT16 dx, INT16 dy,
 301                                const RECT16 *rect, const RECT16 *clipRect,
 302                                HRGN16 hrgnUpdate, LPRECT16 rcUpdate,
 303                                UINT16 flags )
 304 {
 305     RECT32 rect32, clipRect32, rcUpdate32;
 306     BOOL16 ret;
 307
 308     if (rect) CONV_RECT16TO32( rect, &rect32 );
 309     if (clipRect) CONV_RECT16TO32( clipRect, &clipRect32 );
 310     ret = ScrollWindowEx32( hwnd, dx, dy, rect ? &rect32 : NULL,
 311                             clipRect ? &clipRect32 : NULL, hrgnUpdate,
 312                             (rcUpdate) ? &rcUpdate32 : NULL, flags );
 313     if (rcUpdate) CONV_RECT32TO16( &rcUpdate32, rcUpdate );
 314     return ret;
 315 }
 316
 317 /*************************************************************************
 318  *             SCROLL_FixCaret
 319  */
 320 static BOOL32 SCROLL_FixCaret(HWND32 hWnd, LPRECT32 lprc, UINT32 flags)
 321 {
 322    HWND32 hCaret = CARET_GetHwnd();
 323
 324    if( hCaret )
 325    {
 326        RECT32   rc;
 327        CARET_GetRect( &rc );
 328        if( hCaret == hWnd ||
 329           (flags & SW_SCROLLCHILDREN && IsChild32(hWnd, hCaret)) )
 330        {
 331            POINT32     pt;
 332
 333            pt.x = rc.left; pt.y = rc.top;
 334            MapWindowPoints32( hCaret, hWnd, (LPPOINT32)&rc, 2 );
 335            if( IntersectRect32(lprc, lprc, &rc) )
 336            {
 337                HideCaret32(0);
 338                lprc->left = pt.x; lprc->top = pt.y;
 339                return TRUE;
 340            }
 341        }
 342    }
 343    return FALSE;
 344 }
 345
 346 /*************************************************************************
 347  *             ScrollWindowEx32   (USER32.450)
 348  *
 349  * NOTE: Use this function instead of ScrollWindow32
 350  */
 351 INT32 WINAPI ScrollWindowEx32( HWND32 hwnd, INT32 dx, INT32 dy,
 352                                const RECT32 *rect, const RECT32 *clipRect,
 353                                HRGN32 hrgnUpdate, LPRECT32 rcUpdate,
 354                                UINT32 flags )
 355 {
 356     INT32  retVal = NULLREGION;
 357     BOOL32 bCaret = FALSE, bOwnRgn = TRUE;
 358     RECT32 rc, cliprc;
 359     WND*   wnd = WIN_FindWndPtr( hwnd );
 360
 361     if( !wnd || !WIN_IsWindowDrawable( wnd, TRUE )) return ERROR;
 362
 363     if (rect == NULL) GetClientRect32(hwnd, &rc);
 364     else rc = *rect;
 365
 366     if (clipRect) IntersectRect32(&cliprc,&rc,clipRect);
 367     else cliprc = rc;
 368
 369     if (!IsRectEmpty32(&cliprc) && (dx || dy))
 370     {
 371         DC*     dc;
 372         HDC32   hDC;
 373         BOOL32  bUpdate = (rcUpdate || hrgnUpdate || flags & (SW_INVALIDATE | SW_ERASE));
 374         HRGN32  hrgnClip = CreateRectRgnIndirect32(&cliprc);
 375
 376 TRACE(scroll,"%04x, %d,%d hrgnUpdate=%04x rcUpdate = %p \
 377 cliprc = (%d,%d-%d,%d), rc=(%d,%d-%d,%d) %04x\n",
 378 (HWND16)hwnd, dx, dy, hrgnUpdate, rcUpdate,
 379 clipRect?clipRect->left:0, clipRect?clipRect->top:0, clipRect?clipRect->right:0, clipRect?clipRect->bottom:0,
 380 rect?rect->left:0, rect?rect->top:0, rect ?rect->right:0, rect ?rect->bottom:0, (UINT16)flags );
 381
 382         rc = cliprc;
 383         bCaret = SCROLL_FixCaret(hwnd, &rc, flags);
 384
 385         if( hrgnUpdate ) bOwnRgn = FALSE;
 386         else if( bUpdate ) hrgnUpdate = CreateRectRgn32( 0, 0, 0, 0 );
 387
 388         hDC = GetDCEx32( hwnd, hrgnClip, DCX_CACHE | DCX_USESTYLE |
 389                        ((flags & SW_SCROLLCHILDREN) ? DCX_NOCLIPCHILDREN : 0) );
 390         if( (dc = (DC *)GDI_GetObjPtr(hDC, DC_MAGIC)) )
 391         {
 392             POINT32 dst, src;
 393
 394             if( dx > 0 ) dst.x = (src.x = dc->w.DCOrgX + cliprc.left) + dx;
 395             else src.x = (dst.x = dc->w.DCOrgX + cliprc.left) - dx;
 396
 397             if( dy > 0 ) dst.y = (src.y = dc->w.DCOrgY + cliprc.top) + dy;
 398             else src.y = (dst.y = dc->w.DCOrgY + cliprc.top) - dy;
 399
 400             if( bUpdate ) /* handles non-Wine windows hanging over the scrolled area */
 401                 TSXSetGraphicsExposures( display, dc->u.x.gc, True );
 402
 403             TSXSetFunction( display, dc->u.x.gc, GXcopy );
 404             TSXCopyArea( display, dc->u.x.drawable, dc->u.x.drawable, dc->u.x.gc,
 405                        src.x, src.y, cliprc.right - cliprc.left - abs(dx),
 406                        cliprc.bottom - cliprc.top - abs(dy), dst.x, dst.y );
 407
 408             if( bUpdate )
 409                 TSXSetGraphicsExposures( display, dc->u.x.gc, False );
 410
 411             if( dc->w.hVisRgn && bUpdate )
 412             {
 413                 CombineRgn32( hrgnUpdate, dc->w.hVisRgn, hrgnClip, RGN_AND );
 414                 OffsetRgn32( hrgnUpdate, dx, dy );
 415                 CombineRgn32( hrgnUpdate, dc->w.hVisRgn, hrgnUpdate, RGN_DIFF );
 416                 CombineRgn32( hrgnUpdate, hrgnUpdate, hrgnClip, RGN_AND );
 417
 418                 if( rcUpdate ) GetRgnBox32( hrgnUpdate, rcUpdate );
 419             }
 420             ReleaseDC32(hwnd, hDC);
 421         }
 422
 423         if( wnd->hrgnUpdate > 1 )
 424         {
 425             if( rect || clipRect )
 426             {
 427                 if( (CombineRgn32( hrgnClip, hrgnClip,
 428                                    wnd->hrgnUpdate, RGN_AND ) != NULLREGION) )
 429                 {
 430                     CombineRgn32( wnd->hrgnUpdate, wnd->hrgnUpdate, hrgnClip, RGN_DIFF );
 431                     OffsetRgn32( hrgnClip, dx, dy );
 432                     CombineRgn32( wnd->hrgnUpdate, wnd->hrgnUpdate, hrgnClip, RGN_OR );
 433                 }
 434             }
 435             else
 436                 OffsetRgn32( wnd->hrgnUpdate, dx, dy );
 437         }
 438
 439         if( flags & SW_SCROLLCHILDREN )
 440         {
 441             RECT32      r;
 442             WND*        w;
 443             for( w = wnd->child; w; w = w->next )
 444             {
 445                  CONV_RECT16TO32( &w->rectWindow, &r );
 446                  if( !clipRect || IntersectRect32(&r, &r, &cliprc) )
 447                      SetWindowPos32(w->hwndSelf, 0, w->rectWindow.left + dx,
 448                                     w->rectWindow.top  + dy, 0,0, SWP_NOZORDER |
 449                                     SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOREDRAW |
 450                                     SWP_DEFERERASE );
 451             }
 452         }
 453
 454         if( flags & (SW_INVALIDATE | SW_ERASE) )
 455             PAINT_RedrawWindow( hwnd, NULL, hrgnUpdate, RDW_INVALIDATE | RDW_ERASE |
 456                 ((flags & SW_ERASE) ? RDW_ERASENOW : 0) | ((flags & SW_SCROLLCHILDREN) ? RDW_ALLCHILDREN : 0 ), 0 );
 457
 458         if( bCaret )
 459         {
 460             SetCaretPos32( rc.left + dx, rc.top + dy );
 461             ShowCaret32(0);
 462         }
 463
 464         if( bOwnRgn && hrgnUpdate ) DeleteObject32( hrgnUpdate );
 465         DeleteObject32( hrgnClip );
 466     }
 467     return retVal;
 468 }
 469