vcl/source/window/cursor.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <memory>
  21
  22 #include <comphelper/lok.hxx>
  23 #include <vcl/svapp.hxx>
  24 #include <vcl/timer.hxx>
  25 #include <vcl/settings.hxx>
  26 #include <vcl/window.hxx>
  27 #include <vcl/cursor.hxx>
  28
  29 #include <window.h>
  30
  31 #include <tools/poly.hxx>
  32
  33 struct ImplCursorData
  34 {
  35     AutoTimer       maTimer;            // Timer
  36     Point           maPixPos;           // Pixel-Position
  37     Point           maPixRotOff;        // Pixel-Offset-Position
  38     Size            maPixSize;          // Pixel-Size
  39     long            mnPixSlant;         // Pixel-Slant
  40     short           mnOrientation;      // Pixel-Orientation
  41     CursorDirection mnDirection;        // indicates writing direction
  42     sal_uInt16      mnStyle;            // Cursor-Style
  43     bool            mbCurVisible;       // Ist Cursor aktuell sichtbar
  44     VclPtr<vcl::Window> mpWindow;           // Zugeordnetes Windows
  45 };
  46
  47 static void ImplCursorInvert( ImplCursorData* pData )
  48 {
  49     vcl::Window* pWindow  = pData->mpWindow;
  50     std::unique_ptr<PaintBufferGuard> pGuard;
  51     const bool bDoubleBuffering = pWindow->SupportsDoubleBuffering();
  52     if (bDoubleBuffering)
  53         pGuard.reset(new PaintBufferGuard(pWindow->ImplGetWindowImpl()->mpFrameData, pWindow));
  54     vcl::RenderContext* pRenderContext = bDoubleBuffering ? pGuard->GetRenderContext() : pWindow;
  55     Rectangle aPaintRect;
  56     bool    bMapMode = pRenderContext->IsMapModeEnabled();
  57     pRenderContext->EnableMapMode( false );
  58     InvertFlags nInvertStyle;
  59     if ( pData->mnStyle & CURSOR_SHADOW )
  60         nInvertStyle = InvertFlags::N50;
  61     else
  62         nInvertStyle = InvertFlags::NONE;
  63
  64     Rectangle aRect( pData->maPixPos, pData->maPixSize );
  65     if ( pData->mnDirection != CursorDirection::NONE || pData->mnOrientation || pData->mnPixSlant )
  66     {
  67         tools::Polygon aPoly( aRect );
  68         if( aPoly.GetSize() == 5 )
  69         {
  70             aPoly[1].X() += 1;  // include the right border
  71             aPoly[2].X() += 1;
  72             if ( pData->mnPixSlant )
  73             {
  74                 Point aPoint = aPoly.GetPoint( 0 );
  75                 aPoint.X() += pData->mnPixSlant;
  76                 aPoly.SetPoint( aPoint, 0 );
  77                 aPoly.SetPoint( aPoint, 4 );
  78                 aPoint = aPoly.GetPoint( 1 );
  79                 aPoint.X() += pData->mnPixSlant;
  80                 aPoly.SetPoint( aPoint, 1 );
  81             }
  82
  83             // apply direction flag after slant to use the correct shape
  84             if ( pData->mnDirection != CursorDirection::NONE)
  85             {
  86                 Point pAry[7];
  87                 int delta = 3*aRect.getWidth()+1;
  88                 if( pData->mnDirection == CursorDirection::LTR )
  89                 {
  90                     // left-to-right
  91                     pAry[0] = aPoly.GetPoint( 0 );
  92                     pAry[1] = aPoly.GetPoint( 1 );
  93                     pAry[2] = pAry[1];
  94                     pAry[2].X() += delta;
  95                     pAry[3] =  pAry[1];
  96                     pAry[3].Y() += delta;
  97                     pAry[4] = aPoly.GetPoint( 2 );
  98                     pAry[5] = aPoly.GetPoint( 3 );
  99                     pAry[6] = aPoly.GetPoint( 4 );
 100                 }
 101                 else if( pData->mnDirection == CursorDirection::RTL )
 102                 {
 103                     // right-to-left
 104                     pAry[0] = aPoly.GetPoint( 0 );
 105                     pAry[1] = aPoly.GetPoint( 1 );
 106                     pAry[2] = aPoly.GetPoint( 2 );
 107                     pAry[3] = aPoly.GetPoint( 3 );
 108                     pAry[4] = pAry[0];
 109                     pAry[4].Y() += delta;
 110                     pAry[5] =  pAry[0];
 111                     pAry[5].X() -= delta;
 112                     pAry[6] = aPoly.GetPoint( 4 );
 113                 }
 114                 aPoly = tools::Polygon( 7, pAry);
 115             }
 116
 117             if ( pData->mnOrientation )
 118                 aPoly.Rotate( pData->maPixRotOff, pData->mnOrientation );
 119             pRenderContext->Invert( aPoly, nInvertStyle );
 120             if (bDoubleBuffering)
 121                 aPaintRect = aPoly.GetBoundRect();
 122         }
 123     }
 124     else
 125     {
 126         pRenderContext->Invert( aRect, nInvertStyle );
 127         if (bDoubleBuffering)
 128             aPaintRect = aRect;
 129     }
 130     pRenderContext->EnableMapMode( bMapMode );
 131     if (bDoubleBuffering)
 132         pGuard->SetPaintRect(pRenderContext->PixelToLogic(aPaintRect));
 133 }
 134
 135 void vcl::Cursor::ImplDraw()
 136 {
 137     if ( mpData && mpData->mpWindow && !mpData->mbCurVisible )
 138     {
 139         vcl::Window* pWindow         = mpData->mpWindow;
 140         mpData->maPixPos        = pWindow->LogicToPixel( maPos );
 141         mpData->maPixSize       = pWindow->LogicToPixel( maSize );
 142         mpData->mnPixSlant      = pWindow->LogicToPixel( Size( mnSlant, 0 ) ).Width();
 143         mpData->mnOrientation   = mnOrientation;
 144         mpData->mnDirection     = mnDirection;
 145
 146         // correct the position with the offset
 147         mpData->maPixRotOff = mpData->maPixPos;
 148
 149         // use width (as set in Settings) if size is 0,
 150         if ( !mpData->maPixSize.Width() )
 151             mpData->maPixSize.Width() = pWindow->GetSettings().GetStyleSettings().GetCursorSize();
 152
 153         // calculate output area and display
 154         ImplCursorInvert( mpData );
 155         mpData->mbCurVisible = true;
 156     }
 157 }
 158
 159 void vcl::Cursor::ImplRestore()
 160 {
 161     assert( mpData && mpData->mbCurVisible );
 162
 163     ImplCursorInvert( mpData );
 164     mpData->mbCurVisible = false;
 165 }
 166
 167 void vcl::Cursor::ImplDoShow( bool bDrawDirect, bool bRestore )
 168 {
 169     if ( mbVisible )
 170     {
 171         vcl::Window* pWindow;
 172         if ( mpWindow )
 173             pWindow = mpWindow;
 174         else
 175         {
 176             // show the cursor, if there is an active window and the cursor
 177             // has been selected in this window
 178             pWindow = Application::GetFocusWindow();
 179             if ( !pWindow || (pWindow->mpWindowImpl->mpCursor != this) || pWindow->mpWindowImpl->mbInPaint
 180                 || !pWindow->mpWindowImpl->mpFrameData->mbHasFocus )
 181                 pWindow = nullptr;
 182         }
 183
 184         if ( pWindow )
 185         {
 186             if ( !mpData )
 187             {
 188                 mpData = new ImplCursorData;
 189                 mpData->mbCurVisible = false;
 190                 mpData->maTimer.SetTimeoutHdl( LINK( this, Cursor, ImplTimerHdl ) );
 191                 mpData->maTimer.SetDebugName( "vcl ImplCursorData maTimer" );
 192             }
 193
 194             mpData->mpWindow    = pWindow;
 195             mpData->mnStyle     = mnStyle;
 196             if ( bDrawDirect || bRestore )
 197                 ImplDraw();
 198
 199             if ( !mpWindow && ! ( ! bDrawDirect && mpData->maTimer.IsActive()) )
 200             {
 201                 mpData->maTimer.SetTimeout( pWindow->GetSettings().GetStyleSettings().GetCursorBlinkTime() );
 202                 if ( mpData->maTimer.GetTimeout() != STYLE_CURSOR_NOBLINKTIME )
 203                     mpData->maTimer.Start();
 204                 else if ( !mpData->mbCurVisible )
 205                     ImplDraw();
 206                 LOKNotify( pWindow, "cursor_invalidate" );
 207                 LOKNotify( pWindow, "cursor_visible" );
 208             }
 209         }
 210     }
 211 }
 212
 213 void vcl::Cursor::LOKNotify( vcl::Window* pWindow, const OUString& rAction )
 214 {
 215     if (VclPtr<vcl::Window> pParent = pWindow->GetParentWithLOKNotifier())
 216     {
 217         assert(pWindow && "Cannot notify without a window");
 218         assert(mpData && "Require ImplCursorData");
 219         assert(comphelper::LibreOfficeKit::isActive());
 220
 221         if (comphelper::LibreOfficeKit::isDialogPainting())
 222             return;
 223
 224         const vcl::ILibreOfficeKitNotifier* pNotifier = pParent->GetLOKNotifier();
 225         std::vector<vcl::LOKPayloadItem> aItems;
 226         if (rAction == "cursor_visible")
 227             aItems.emplace_back("visible", mpData->mbCurVisible ? "true" : "false");
 228         else if (rAction == "cursor_invalidate")
 229         {
 230             const long nX = pWindow->GetOutOffXPixel() + pWindow->LogicToPixel(GetPos()).X();
 231             const long nY = pWindow->GetOutOffYPixel() + pWindow->LogicToPixel(GetPos()).Y();
 232             Size aSize = pWindow->LogicToPixel(GetSize());
 233             if (!aSize.Width())
 234                 aSize.Width() = pWindow->GetSettings().GetStyleSettings().GetCursorSize();
 235
 236             const Rectangle aRect(Point(nX, nY), aSize);
 237             aItems.emplace_back("rectangle", aRect.toString());
 238         }
 239
 240         pNotifier->notifyWindow(pParent->GetLOKWindowId(), rAction, aItems);
 241     }
 242 }
 243
 244 bool vcl::Cursor::ImplDoHide( bool bSuspend )
 245 {
 246     bool bWasCurVisible = false;
 247     if ( mpData && mpData->mpWindow )
 248     {
 249         bWasCurVisible = mpData->mbCurVisible;
 250         if ( mpData->mbCurVisible )
 251             ImplRestore();
 252
 253         if ( !bSuspend )
 254         {
 255             LOKNotify( mpData->mpWindow, "cursor_visible" );
 256             mpData->maTimer.Stop();
 257             mpData->mpWindow = nullptr;
 258         }
 259     }
 260     return bWasCurVisible;
 261 }
 262
 263 void vcl::Cursor::ImplShow()
 264 {
 265     ImplDoShow( true/*bDrawDirect*/, false );
 266 }
 267
 268 void vcl::Cursor::ImplHide()
 269 {
 270     ImplDoHide( false );
 271 }
 272
 273 void vcl::Cursor::ImplResume( bool bRestore )
 274 {
 275     ImplDoShow( false, bRestore );
 276 }
 277
 278 bool vcl::Cursor::ImplSuspend()
 279 {
 280     return ImplDoHide( true );
 281 }
 282
 283 void vcl::Cursor::ImplNew()
 284 {
 285     if ( mbVisible && mpData && mpData->mpWindow )
 286     {
 287         if ( mpData->mbCurVisible )
 288             ImplRestore();
 289
 290         ImplDraw();
 291         if ( !mpWindow )
 292         {
 293             LOKNotify( mpData->mpWindow, "cursor_invalidate" );
 294             if ( mpData->maTimer.GetTimeout() != STYLE_CURSOR_NOBLINKTIME )
 295                 mpData->maTimer.Start();
 296         }
 297     }
 298 }
 299
 300 IMPL_LINK_NOARG(vcl::Cursor, ImplTimerHdl, Timer *, void)
 301 {
 302     if ( mpData->mbCurVisible )
 303         ImplRestore();
 304     else
 305         ImplDraw();
 306 }
 307
 308 vcl::Cursor::Cursor()
 309 {
 310     mpData          = nullptr;
 311     mpWindow        = nullptr;
 312     mnSlant         = 0;
 313     mnOrientation   = 0;
 314     mnDirection     = CursorDirection::NONE;
 315     mnStyle         = 0;
 316     mbVisible       = false;
 317 }
 318
 319 vcl::Cursor::Cursor( const Cursor& rCursor ) :
 320     maSize( rCursor.maSize ),
 321     maPos( rCursor.maPos )
 322 {
 323     mpData          = nullptr;
 324     mpWindow        = nullptr;
 325     mnSlant         = rCursor.mnSlant;
 326     mnOrientation   = rCursor.mnOrientation;
 327     mnDirection     = rCursor.mnDirection;
 328     mnStyle         = 0;
 329     mbVisible       = rCursor.mbVisible;
 330 }
 331
 332 vcl::Cursor::~Cursor()
 333 {
 334     if ( mpData )
 335     {
 336         if ( mpData->mbCurVisible )
 337             ImplRestore();
 338
 339         delete mpData;
 340     }
 341 }
 342
 343 void vcl::Cursor::SetStyle( sal_uInt16 nStyle )
 344 {
 345     if ( mnStyle != nStyle )
 346     {
 347         mnStyle = nStyle;
 348         ImplNew();
 349     }
 350 }
 351
 352 void vcl::Cursor::Show()
 353 {
 354     if ( !mbVisible )
 355     {
 356         mbVisible = true;
 357         ImplShow();
 358     }
 359 }
 360
 361 void vcl::Cursor::Hide()
 362 {
 363     if ( mbVisible )
 364     {
 365         mbVisible = false;
 366         ImplHide();
 367     }
 368 }
 369
 370 void vcl::Cursor::SetWindow( vcl::Window* pWindow )
 371 {
 372     if ( mpWindow.get() != pWindow )
 373     {
 374         mpWindow = pWindow;
 375         ImplNew();
 376     }
 377 }
 378
 379 void vcl::Cursor::SetPos( const Point& rPoint )
 380 {
 381     if ( maPos != rPoint )
 382     {
 383         maPos = rPoint;
 384         ImplNew();
 385     }
 386 }
 387
 388 void vcl::Cursor::SetSize( const Size& rSize )
 389 {
 390     if ( maSize != rSize )
 391     {
 392         maSize = rSize;
 393         ImplNew();
 394     }
 395 }
 396
 397 void vcl::Cursor::SetWidth( long nNewWidth )
 398 {
 399     if ( maSize.Width() != nNewWidth )
 400     {
 401         maSize.Width() = nNewWidth;
 402         ImplNew();
 403     }
 404 }
 405
 406 void vcl::Cursor::SetOrientation( short nNewOrientation )
 407 {
 408     if ( mnOrientation != nNewOrientation )
 409     {
 410         mnOrientation = nNewOrientation;
 411         ImplNew();
 412     }
 413 }
 414
 415 void vcl::Cursor::SetDirection( CursorDirection nNewDirection )
 416 {
 417     if ( mnDirection != nNewDirection )
 418     {
 419         mnDirection = nNewDirection;
 420         ImplNew();
 421     }
 422 }
 423
 424 vcl::Cursor& vcl::Cursor::operator=( const vcl::Cursor& rCursor )
 425 {
 426     maPos           = rCursor.maPos;
 427     maSize          = rCursor.maSize;
 428     mnSlant         = rCursor.mnSlant;
 429     mnOrientation   = rCursor.mnOrientation;
 430     mnDirection     = rCursor.mnDirection;
 431     mbVisible       = rCursor.mbVisible;
 432     ImplNew();
 433
 434     return *this;
 435 }
 436
 437 bool vcl::Cursor::operator==( const vcl::Cursor& rCursor ) const
 438 {
 439     return
 440         ((maPos         == rCursor.maPos)           &&
 441          (maSize        == rCursor.maSize)          &&
 442          (mnSlant       == rCursor.mnSlant)         &&
 443          (mnOrientation == rCursor.mnOrientation)   &&
 444          (mnDirection   == rCursor.mnDirection)     &&
 445          (mbVisible     == rCursor.mbVisible))
 446         ;
 447 }
 448
 449 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */