LCOV - code coverage report
Current view: top level - vcl/source/window - cursor.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 217 0.0 %
Date: 2014-04-14 Functions: 0 28 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <vcl/svapp.hxx>
      21             : #include <vcl/timer.hxx>
      22             : #include <vcl/settings.hxx>
      23             : #include <vcl/window.hxx>
      24             : #include <vcl/cursor.hxx>
      25             : 
      26             : #include <window.h>
      27             : 
      28             : #include <tools/poly.hxx>
      29             : 
      30           0 : struct ImplCursorData
      31             : {
      32             :     AutoTimer       maTimer;            // Timer
      33             :     Point           maPixPos;           // Pixel-Position
      34             :     Point           maPixRotOff;        // Pixel-Offset-Position
      35             :     Size            maPixSize;          // Pixel-Size
      36             :     long            mnPixSlant;         // Pixel-Slant
      37             :     short           mnOrientation;      // Pixel-Orientation
      38             :     unsigned char   mnDirection;        // indicates writing direction
      39             :     sal_uInt16          mnStyle;            // Cursor-Style
      40             :     bool            mbCurVisible;       // Ist Cursor aktuell sichtbar
      41             :     Window*         mpWindow;           // Zugeordnetes Windows
      42             : };
      43             : 
      44           0 : static void ImplCursorInvert( ImplCursorData* pData )
      45             : {
      46           0 :     Window* pWindow  = pData->mpWindow;
      47           0 :     bool    bMapMode = pWindow->IsMapModeEnabled();
      48           0 :     pWindow->EnableMapMode( false );
      49             :     sal_uInt16 nInvertStyle;
      50           0 :     if ( pData->mnStyle & CURSOR_SHADOW )
      51           0 :         nInvertStyle = INVERT_50;
      52             :     else
      53           0 :         nInvertStyle = 0;
      54             : 
      55           0 :     Rectangle aRect( pData->maPixPos, pData->maPixSize );
      56           0 :     if ( pData->mnDirection || pData->mnOrientation || pData->mnPixSlant )
      57             :     {
      58           0 :         Polygon aPoly( aRect );
      59           0 :         if( aPoly.GetSize() == 5 )
      60             :         {
      61           0 :             aPoly[1].X() += 1;  // include the right border
      62           0 :             aPoly[2].X() += 1;
      63           0 :             if ( pData->mnPixSlant )
      64             :             {
      65           0 :                 Point aPoint = aPoly.GetPoint( 0 );
      66           0 :                 aPoint.X() += pData->mnPixSlant;
      67           0 :                 aPoly.SetPoint( aPoint, 0 );
      68           0 :                 aPoly.SetPoint( aPoint, 4 );
      69           0 :                 aPoint = aPoly.GetPoint( 1 );
      70           0 :                 aPoint.X() += pData->mnPixSlant;
      71           0 :                 aPoly.SetPoint( aPoint, 1 );
      72             :             }
      73             : 
      74             :             // apply direction flag after slant to use the correct shape
      75           0 :             if ( pData->mnDirection )
      76             :             {
      77           0 :                 Point pAry[7];
      78           0 :                 int delta = 3*aRect.getWidth()+1;
      79           0 :                 if( pData->mnDirection == CURSOR_DIRECTION_LTR )
      80             :                 {
      81             :                     // left-to-right
      82           0 :                     pAry[0] = aPoly.GetPoint( 0 );
      83           0 :                     pAry[1] = aPoly.GetPoint( 1 );
      84           0 :                     pAry[2] = pAry[1];
      85           0 :                     pAry[2].X() += delta;
      86           0 :                     pAry[3] =  pAry[1];
      87           0 :                     pAry[3].Y() += delta;
      88           0 :                     pAry[4] = aPoly.GetPoint( 2 );
      89           0 :                     pAry[5] = aPoly.GetPoint( 3 );
      90           0 :                     pAry[6] = aPoly.GetPoint( 4 );
      91             :                 }
      92           0 :                 else if( pData->mnDirection == CURSOR_DIRECTION_RTL )
      93             :                 {
      94             :                     // right-to-left
      95           0 :                     pAry[0] = aPoly.GetPoint( 0 );
      96           0 :                     pAry[1] = aPoly.GetPoint( 1 );
      97           0 :                     pAry[2] = aPoly.GetPoint( 2 );
      98           0 :                     pAry[3] = aPoly.GetPoint( 3 );
      99           0 :                     pAry[4] = pAry[0];
     100           0 :                     pAry[4].Y() += delta;
     101           0 :                     pAry[5] =  pAry[0];
     102           0 :                     pAry[5].X() -= delta;
     103           0 :                     pAry[6] = aPoly.GetPoint( 4 );
     104             :                 }
     105           0 :                 aPoly = Polygon( 7, pAry);
     106             :             }
     107             : 
     108           0 :             if ( pData->mnOrientation )
     109           0 :                 aPoly.Rotate( pData->maPixRotOff, pData->mnOrientation );
     110           0 :             pWindow->Invert( aPoly, nInvertStyle );
     111           0 :         }
     112             :     }
     113             :     else
     114           0 :         pWindow->Invert( aRect, nInvertStyle );
     115           0 :     pWindow->EnableMapMode( bMapMode );
     116           0 : }
     117             : 
     118           0 : void Cursor::ImplDraw()
     119             : {
     120           0 :     if ( mpData && mpData->mpWindow && !mpData->mbCurVisible )
     121             :     {
     122             :         // SAL_DEBUG("Cursor::ImplDraw");
     123           0 :         Window* pWindow         = mpData->mpWindow;
     124           0 :         mpData->maPixPos        = pWindow->LogicToPixel( maPos );
     125           0 :         mpData->maPixSize       = pWindow->LogicToPixel( maSize );
     126           0 :         mpData->mnPixSlant      = pWindow->LogicToPixel( Size( mnSlant, 0 ) ).Width();
     127           0 :         mpData->mnOrientation   = mnOrientation;
     128           0 :         mpData->mnDirection     = mnDirection;
     129             : 
     130             :         // correct the position with the offset
     131           0 :         mpData->maPixRotOff = mpData->maPixPos;
     132             : 
     133             :         // use width (as set in Settings) if size is 0,
     134           0 :         if ( !mpData->maPixSize.Width() )
     135           0 :             mpData->maPixSize.Width() = pWindow->GetSettings().GetStyleSettings().GetCursorSize();
     136             : 
     137             :         // calculate output area and display
     138           0 :         ImplCursorInvert( mpData );
     139           0 :         mpData->mbCurVisible = true;
     140             :     }
     141           0 : }
     142             : 
     143           0 : void Cursor::ImplRestore()
     144             : {
     145           0 :     if ( mpData && mpData->mbCurVisible )
     146             :     {
     147             :         // SAL_DEBUG("Cursor::ImplRestore");
     148           0 :         ImplCursorInvert( mpData );
     149           0 :         mpData->mbCurVisible = false;
     150             :     }
     151           0 : }
     152             : 
     153           0 : void Cursor::ImplDoShow( bool bDrawDirect, bool bRestore )
     154             : {
     155           0 :     if ( mbVisible )
     156             :     {
     157             :         Window* pWindow;
     158           0 :         if ( mpWindow )
     159           0 :             pWindow = mpWindow;
     160             :         else
     161             :         {
     162             :             // show the cursor, if there is an active window and the cursor
     163             :             // has been selected in this window
     164           0 :             pWindow = Application::GetFocusWindow();
     165           0 :             if ( !pWindow || (pWindow->mpWindowImpl->mpCursor != this) || pWindow->mpWindowImpl->mbInPaint
     166           0 :                 || !pWindow->mpWindowImpl->mpFrameData->mbHasFocus )
     167           0 :                 pWindow = NULL;
     168             :         }
     169             : 
     170           0 :         if ( pWindow )
     171             :         {
     172           0 :             if ( !mpData )
     173             :             {
     174           0 :                 mpData = new ImplCursorData;
     175           0 :                 mpData->mbCurVisible = false;
     176           0 :                 mpData->maTimer.SetTimeoutHdl( LINK( this, Cursor, ImplTimerHdl ) );
     177             :             }
     178             : 
     179           0 :             mpData->mpWindow    = pWindow;
     180           0 :             mpData->mnStyle     = mnStyle;
     181           0 :             if ( bDrawDirect || bRestore )
     182           0 :                 ImplDraw();
     183             : 
     184           0 :             if ( !mpWindow && ! ( ! bDrawDirect && mpData->maTimer.IsActive()) )
     185             :             {
     186           0 :                 mpData->maTimer.SetTimeout( pWindow->GetSettings().GetStyleSettings().GetCursorBlinkTime() );
     187           0 :                 if ( mpData->maTimer.GetTimeout() != STYLE_CURSOR_NOBLINKTIME )
     188           0 :                     mpData->maTimer.Start();
     189           0 :                 else if ( !mpData->mbCurVisible )
     190           0 :                     ImplDraw();
     191             :             }
     192             :         }
     193             :     }
     194           0 : }
     195             : 
     196           0 : bool Cursor::ImplDoHide( bool bSuspend )
     197             : {
     198           0 :     bool bWasCurVisible = false;
     199           0 :     if ( mpData && mpData->mpWindow )
     200             :     {
     201           0 :         bWasCurVisible = mpData->mbCurVisible;
     202           0 :         if ( mpData->mbCurVisible )
     203           0 :             ImplRestore();
     204             : 
     205           0 :         if ( !bSuspend )
     206             :         {
     207           0 :             mpData->maTimer.Stop();
     208           0 :             mpData->mpWindow = NULL;
     209             :         }
     210             :     }
     211           0 :     return bWasCurVisible;
     212             : }
     213             : 
     214           0 : void Cursor::ImplShow( bool bDrawDirect )
     215             : {
     216           0 :     ImplDoShow( bDrawDirect, false );
     217           0 : }
     218             : 
     219           0 : void Cursor::ImplHide( bool i_bStopTimer )
     220             : {
     221             :     assert( i_bStopTimer );
     222           0 :     ImplDoHide( !i_bStopTimer );
     223           0 : }
     224             : 
     225           0 : void Cursor::ImplResume( bool bRestore )
     226             : {
     227           0 :     ImplDoShow( false, bRestore );
     228           0 : }
     229             : 
     230           0 : bool Cursor::ImplSuspend()
     231             : {
     232           0 :     return ImplDoHide( true );
     233             : }
     234             : 
     235           0 : void Cursor::ImplNew()
     236             : {
     237           0 :     if ( mbVisible && mpData && mpData->mpWindow )
     238             :     {
     239           0 :         if ( mpData->mbCurVisible )
     240           0 :             ImplRestore();
     241             : 
     242           0 :         ImplDraw();
     243           0 :         if ( !mpWindow )
     244             :         {
     245           0 :             if ( mpData->maTimer.GetTimeout() != STYLE_CURSOR_NOBLINKTIME )
     246           0 :                 mpData->maTimer.Start();
     247             :         }
     248             :     }
     249           0 : }
     250             : 
     251           0 : IMPL_LINK_NOARG(Cursor, ImplTimerHdl)
     252             : {
     253           0 :     if ( mpData->mbCurVisible )
     254           0 :         ImplRestore();
     255             :     else
     256           0 :         ImplDraw();
     257           0 :     return 0;
     258             : }
     259             : 
     260           0 : Cursor::Cursor()
     261             : {
     262           0 :     mpData          = NULL;
     263           0 :     mpWindow        = NULL;
     264           0 :     mnSlant         = 0;
     265           0 :     mnOrientation   = 0;
     266           0 :     mnDirection     = 0;
     267           0 :     mnStyle         = 0;
     268           0 :     mbVisible       = false;
     269           0 : }
     270             : 
     271           0 : Cursor::Cursor( const Cursor& rCursor ) :
     272             :     maSize( rCursor.maSize ),
     273           0 :     maPos( rCursor.maPos )
     274             : {
     275           0 :     mpData          = NULL;
     276           0 :     mpWindow        = NULL;
     277           0 :     mnSlant         = rCursor.mnSlant;
     278           0 :     mnOrientation   = rCursor.mnOrientation;
     279           0 :     mnDirection     = rCursor.mnDirection;
     280           0 :     mnStyle         = 0;
     281           0 :     mbVisible       = rCursor.mbVisible;
     282           0 : }
     283             : 
     284           0 : Cursor::~Cursor()
     285             : {
     286           0 :     if ( mpData )
     287             :     {
     288           0 :         if ( mpData->mbCurVisible )
     289           0 :             ImplRestore();
     290             : 
     291           0 :         delete mpData;
     292             :     }
     293           0 : }
     294             : 
     295           0 : void Cursor::SetStyle( sal_uInt16 nStyle )
     296             : {
     297           0 :     if ( mnStyle != nStyle )
     298             :     {
     299           0 :         mnStyle = nStyle;
     300           0 :         ImplNew();
     301             :     }
     302           0 : }
     303             : 
     304           0 : void Cursor::Show()
     305             : {
     306           0 :     if ( !mbVisible )
     307             :     {
     308           0 :         mbVisible = true;
     309           0 :         ImplShow();
     310             :     }
     311           0 : }
     312             : 
     313           0 : void Cursor::Hide()
     314             : {
     315           0 :     if ( mbVisible )
     316             :     {
     317           0 :         mbVisible = false;
     318           0 :         ImplHide( true );
     319             :     }
     320           0 : }
     321             : 
     322           0 : void Cursor::SetWindow( Window* pWindow )
     323             : {
     324           0 :     if ( mpWindow != pWindow )
     325             :     {
     326           0 :         mpWindow = pWindow;
     327           0 :         ImplNew();
     328             :     }
     329           0 : }
     330             : 
     331           0 : void Cursor::SetPos( const Point& rPoint )
     332             : {
     333           0 :     if ( maPos != rPoint )
     334             :     {
     335           0 :         maPos = rPoint;
     336           0 :         ImplNew();
     337             :     }
     338           0 : }
     339             : 
     340           0 : void Cursor::SetSize( const Size& rSize )
     341             : {
     342           0 :     if ( maSize != rSize )
     343             :     {
     344           0 :         maSize = rSize;
     345           0 :         ImplNew();
     346             :     }
     347           0 : }
     348             : 
     349           0 : void Cursor::SetWidth( long nNewWidth )
     350             : {
     351           0 :     if ( maSize.Width() != nNewWidth )
     352             :     {
     353           0 :         maSize.Width() = nNewWidth;
     354           0 :         ImplNew();
     355             :     }
     356           0 : }
     357             : 
     358           0 : void Cursor::SetOrientation( short nNewOrientation )
     359             : {
     360           0 :     if ( mnOrientation != nNewOrientation )
     361             :     {
     362           0 :         mnOrientation = nNewOrientation;
     363           0 :         ImplNew();
     364             :     }
     365           0 : }
     366             : 
     367           0 : void Cursor::SetDirection( unsigned char nNewDirection )
     368             : {
     369           0 :     if ( mnDirection != nNewDirection )
     370             :     {
     371           0 :         mnDirection = nNewDirection;
     372           0 :         ImplNew();
     373             :     }
     374           0 : }
     375             : 
     376           0 : Cursor& Cursor::operator=( const Cursor& rCursor )
     377             : {
     378           0 :     maPos           = rCursor.maPos;
     379           0 :     maSize          = rCursor.maSize;
     380           0 :     mnSlant         = rCursor.mnSlant;
     381           0 :     mnOrientation   = rCursor.mnOrientation;
     382           0 :     mnDirection     = rCursor.mnDirection;
     383           0 :     mbVisible       = rCursor.mbVisible;
     384           0 :     ImplNew();
     385             : 
     386           0 :     return *this;
     387             : }
     388             : 
     389           0 : bool Cursor::operator==( const Cursor& rCursor ) const
     390             : {
     391             :     return
     392           0 :         ((maPos         == rCursor.maPos)           &&
     393           0 :          (maSize        == rCursor.maSize)          &&
     394           0 :          (mnSlant       == rCursor.mnSlant)         &&
     395           0 :          (mnOrientation == rCursor.mnOrientation)   &&
     396           0 :          (mnDirection   == rCursor.mnDirection)     &&
     397           0 :          (mbVisible     == rCursor.mbVisible))
     398             :         ;
     399             : }
     400             : 
     401             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10