vcl/source/window/cursor.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: cursor.cxx,v $
  10  * $Revision: 1.13 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33 #include <vcl/svapp.hxx>
  34 #include <vcl/timer.hxx>
  35 #include <vcl/settings.hxx>
  36 #include <vcl/window.hxx>
  37 #include <vcl/window.h>
  38 #include <tools/poly.hxx>
  39 #include <vcl/cursor.hxx>
  40
  41
  42 // =======================================================================
  43
  44 struct ImplCursorData
  45 {
  46     AutoTimer           maTimer;                        // Timer
  47     Point                       maPixPos;                       // Pixel-Position
  48     Point                       maPixRotOff;            // Pixel-Offset-Position
  49     Size                        maPixSize;                      // Pixel-Size
  50     long                        mnPixSlant;             // Pixel-Slant
  51     short                       mnOrientation;          // Pixel-Orientation
  52     unsigned char       mnDirection;            // indicates writing direction
  53     USHORT                      mnStyle;                        // Cursor-Style
  54     BOOL                        mbCurVisible;           // Ist Cursor aktuell sichtbar
  55     Window*             mpWindow;                       // Zugeordnetes Windows
  56 };
  57
  58 // =======================================================================
  59
  60 static void ImplCursorInvert( ImplCursorData* pData )
  61 {
  62     Window* pWindow  = pData->mpWindow;
  63     BOOL        bMapMode = pWindow->IsMapModeEnabled();
  64     pWindow->EnableMapMode( FALSE );
  65     USHORT nInvertStyle;
  66     if ( pData->mnStyle & CURSOR_SHADOW )
  67         nInvertStyle = INVERT_50;
  68     else
  69         nInvertStyle = 0;
  70
  71     Rectangle aRect( pData->maPixPos, pData->maPixSize );
  72     if ( pData->mnDirection || pData->mnOrientation || pData->mnPixSlant )
  73     {
  74         Polygon aPoly( aRect );
  75         if( aPoly.GetSize() == 5 )
  76         {
  77             aPoly[1].X() += 1;  // include the right border
  78             aPoly[2].X() += 1;
  79             if ( pData->mnPixSlant )
  80             {
  81                 Point aPoint = aPoly.GetPoint( 0 );
  82                 aPoint.X() += pData->mnPixSlant;
  83                 aPoly.SetPoint( aPoint, 0 );
  84                 aPoly.SetPoint( aPoint, 4 );
  85                 aPoint = aPoly.GetPoint( 1 );
  86                 aPoint.X() += pData->mnPixSlant;
  87                 aPoly.SetPoint( aPoint, 1 );
  88             }
  89
  90             // apply direction flag after slant to use the correct shape
  91             if ( pData->mnDirection )
  92             {
  93                 Point pAry[7];
  94                 int delta = 3*aRect.getWidth()+1;
  95                 if( pData->mnDirection == CURSOR_DIRECTION_LTR )
  96                 {
  97                     // left-to-right
  98                     pAry[0] = aPoly.GetPoint( 0 );
  99                     pAry[1] = aPoly.GetPoint( 1 );
 100                     pAry[2] = pAry[1];
 101                     pAry[2].X() += delta;
 102                     pAry[3] =  pAry[1];
 103                     pAry[3].Y() += delta;
 104                     pAry[4] = aPoly.GetPoint( 2 );
 105                     pAry[5] = aPoly.GetPoint( 3 );
 106                     pAry[6] = aPoly.GetPoint( 4 );
 107                 }
 108                 else if( pData->mnDirection == CURSOR_DIRECTION_RTL )
 109                 {
 110                     // right-to-left
 111                     pAry[0] = aPoly.GetPoint( 0 );
 112                     pAry[1] = aPoly.GetPoint( 1 );
 113                     pAry[2] = aPoly.GetPoint( 2 );
 114                     pAry[3] = aPoly.GetPoint( 3 );
 115                     pAry[4] = pAry[0];
 116                     pAry[4].Y() += delta;
 117                     pAry[5] =  pAry[0];
 118                     pAry[5].X() -= delta;
 119                     pAry[6] = aPoly.GetPoint( 4 );
 120                 }
 121                 aPoly = Polygon( 7, pAry);
 122             }
 123
 124             if ( pData->mnOrientation )
 125                 aPoly.Rotate( pData->maPixRotOff, pData->mnOrientation );
 126             pWindow->Invert( aPoly, nInvertStyle );
 127         }
 128     }
 129     else
 130         pWindow->Invert( aRect, nInvertStyle );
 131     pWindow->EnableMapMode( bMapMode );
 132 }
 133
 134 // -----------------------------------------------------------------------
 135
 136 void Cursor::ImplDraw()
 137 {
 138     if ( mpData && mpData->mpWindow && !mpData->mbCurVisible )
 139     {
 140         Window* pWindow                 = mpData->mpWindow;
 141         mpData->maPixPos                = pWindow->LogicToPixel( maPos );
 142         mpData->maPixSize               = pWindow->LogicToPixel( maSize );
 143         mpData->mnPixSlant              = pWindow->LogicToPixel( Size( mnSlant, 0 ) ).Width();
 144         mpData->mnOrientation   = mnOrientation;
 145         mpData->mnDirection         = mnDirection;
 146         long nOffsetY                   = pWindow->LogicToPixel( Size( 0, mnOffsetY ) ).Height();
 147
 148         // Position um den Offset korrigieren
 149         mpData->maPixPos.Y() -= nOffsetY;
 150         mpData->maPixRotOff = mpData->maPixPos;
 151         mpData->maPixRotOff.Y() += nOffsetY;
 152
 153         // Wenn groesse 0 ist, nehmen wir die breite, die in den
 154         // Settings eingestellt ist
 155         if ( !mpData->maPixSize.Width() )
 156             mpData->maPixSize.Width() = pWindow->GetSettings().GetStyleSettings().GetCursorSize();
 157
 158         // Ausgabeflaeche berechnen und ausgeben
 159         ImplCursorInvert( mpData );
 160         mpData->mbCurVisible = TRUE;
 161     }
 162 }
 163
 164 // -----------------------------------------------------------------------
 165
 166 void Cursor::ImplRestore()
 167 {
 168     if ( mpData && mpData->mbCurVisible )
 169     {
 170         ImplCursorInvert( mpData );
 171         mpData->mbCurVisible = FALSE;
 172     }
 173 }
 174
 175 // -----------------------------------------------------------------------
 176
 177 void Cursor::ImplShow( BOOL bDrawDirect )
 178 {
 179     if ( mbVisible )
 180     {
 181         Window* pWindow;
 182         if ( mpWindow )
 183             pWindow = mpWindow;
 184         else
 185         {
 186             // Gibt es ein aktives Fenster und ist der Cursor in dieses Fenster
 187             // selektiert, dann zeige den Cursor an
 188             pWindow = Application::GetFocusWindow();
 189             if ( !pWindow || (pWindow->mpWindowImpl->mpCursor != this) || pWindow->mpWindowImpl->mbInPaint
 190                 || !pWindow->mpWindowImpl->mpFrameData->mbHasFocus )
 191                 pWindow = NULL;
 192         }
 193
 194         if ( pWindow )
 195         {
 196             if ( !mpData )
 197             {
 198                 mpData = new ImplCursorData;
 199                 mpData->mbCurVisible = FALSE;
 200                 mpData->maTimer.SetTimeoutHdl( LINK( this, Cursor, ImplTimerHdl ) );
 201             }
 202
 203             mpData->mpWindow    = pWindow;
 204             mpData->mnStyle     = mnStyle;
 205             if ( bDrawDirect )
 206                 ImplDraw();
 207
 208             if ( !mpWindow )
 209             {
 210                 mpData->maTimer.SetTimeout( pWindow->GetSettings().GetStyleSettings().GetCursorBlinkTime() );
 211                 if ( mpData->maTimer.GetTimeout() != STYLE_CURSOR_NOBLINKTIME )
 212                     mpData->maTimer.Start();
 213                 else if ( !mpData->mbCurVisible )
 214                     ImplDraw();
 215             }
 216         }
 217     }
 218 }
 219
 220 // -----------------------------------------------------------------------
 221
 222 void Cursor::ImplHide()
 223 {
 224     if ( mpData && mpData->mpWindow )
 225     {
 226         if ( mpData->mbCurVisible )
 227             ImplRestore();
 228
 229         mpData->maTimer.Stop();
 230         mpData->mpWindow = NULL;
 231     }
 232 }
 233
 234 // -----------------------------------------------------------------------
 235
 236 void Cursor::ImplNew()
 237 {
 238     if ( mbVisible && mpData && mpData->mpWindow )
 239     {
 240         if ( mpData->mbCurVisible )
 241             ImplRestore();
 242
 243         ImplDraw();
 244         if ( !mpWindow )
 245         {
 246             if ( mpData->maTimer.GetTimeout() != STYLE_CURSOR_NOBLINKTIME )
 247                 mpData->maTimer.Start();
 248         }
 249     }
 250 }
 251
 252 // -----------------------------------------------------------------------
 253
 254 IMPL_LINK( Cursor, ImplTimerHdl, AutoTimer*, EMPTYARG )
 255 {
 256     if ( mpData->mbCurVisible )
 257         ImplRestore();
 258     else
 259         ImplDraw();
 260     return 0;
 261 }
 262
 263 // =======================================================================
 264
 265 Cursor::Cursor()
 266 {
 267     mpData                      = NULL;
 268     mpWindow            = NULL;
 269     mnSlant             = 0;
 270     mnOffsetY           = 0;
 271     mnOrientation       = 0;
 272     mnDirection         = 0;
 273     mnStyle             = 0;
 274     mbVisible           = FALSE;
 275 }
 276
 277 // -----------------------------------------------------------------------
 278
 279 Cursor::Cursor( const Cursor& rCursor ) :
 280     maSize( rCursor.maSize ),
 281     maPos( rCursor.maPos )
 282 {
 283     mpData                      = NULL;
 284     mpWindow            = NULL;
 285     mnSlant             = rCursor.mnSlant;
 286     mnOrientation       = rCursor.mnOrientation;
 287     mnDirection         = rCursor.mnDirection;
 288     mnStyle             = 0;
 289     mbVisible           = rCursor.mbVisible;
 290 }
 291
 292 // -----------------------------------------------------------------------
 293
 294 Cursor::~Cursor()
 295 {
 296     if ( mpData )
 297     {
 298         if ( mpData->mbCurVisible )
 299             ImplRestore();
 300
 301         delete mpData;
 302     }
 303 }
 304
 305 // -----------------------------------------------------------------------
 306
 307 void Cursor::SetStyle( USHORT nStyle )
 308 {
 309     if ( mnStyle != nStyle )
 310     {
 311         mnStyle = nStyle;
 312         ImplNew();
 313     }
 314 }
 315
 316 // -----------------------------------------------------------------------
 317
 318 void Cursor::Show()
 319 {
 320     if ( !mbVisible )
 321     {
 322         mbVisible = TRUE;
 323         ImplShow();
 324     }
 325 }
 326
 327 // -----------------------------------------------------------------------
 328
 329 void Cursor::Hide()
 330 {
 331     if ( mbVisible )
 332     {
 333         mbVisible = FALSE;
 334         ImplHide();
 335     }
 336 }
 337
 338 // -----------------------------------------------------------------------
 339
 340 void Cursor::SetWindow( Window* pWindow )
 341 {
 342     if ( mpWindow != pWindow )
 343     {
 344         mpWindow = pWindow;
 345         ImplNew();
 346     }
 347 }
 348
 349 // -----------------------------------------------------------------------
 350
 351 void Cursor::SetPos( const Point& rPoint )
 352 {
 353     if ( maPos != rPoint )
 354     {
 355         maPos = rPoint;
 356         ImplNew();
 357     }
 358 }
 359
 360 // -----------------------------------------------------------------------
 361
 362 void Cursor::SetOffsetY( long nNewOffsetY )
 363 {
 364     if ( mnOffsetY != nNewOffsetY )
 365     {
 366         mnOffsetY = nNewOffsetY;
 367         ImplNew();
 368     }
 369 }
 370
 371 // -----------------------------------------------------------------------
 372
 373 void Cursor::SetSize( const Size& rSize )
 374 {
 375     if ( maSize != rSize )
 376     {
 377         maSize = rSize;
 378         ImplNew();
 379     }
 380 }
 381
 382 // -----------------------------------------------------------------------
 383
 384 void Cursor::SetWidth( long nNewWidth )
 385 {
 386     if ( maSize.Width() != nNewWidth )
 387     {
 388         maSize.Width() = nNewWidth;
 389         ImplNew();
 390     }
 391 }
 392
 393 // -----------------------------------------------------------------------
 394
 395 void Cursor::SetHeight( long nNewHeight )
 396 {
 397     if ( maSize.Height() != nNewHeight )
 398     {
 399         maSize.Height() = nNewHeight;
 400         ImplNew();
 401     }
 402 }
 403
 404 // -----------------------------------------------------------------------
 405
 406 void Cursor::SetSlant( long nNewSlant )
 407 {
 408     if ( mnSlant != nNewSlant )
 409     {
 410         mnSlant = nNewSlant;
 411         ImplNew();
 412     }
 413 }
 414
 415 // -----------------------------------------------------------------------
 416
 417 void Cursor::SetOrientation( short nNewOrientation )
 418 {
 419     if ( mnOrientation != nNewOrientation )
 420     {
 421         mnOrientation = nNewOrientation;
 422         ImplNew();
 423     }
 424 }
 425
 426 // -----------------------------------------------------------------------
 427
 428 void Cursor::SetDirection( unsigned char nNewDirection )
 429 {
 430     if ( mnDirection != nNewDirection )
 431     {
 432         mnDirection = nNewDirection;
 433         ImplNew();
 434     }
 435 }
 436
 437 // -----------------------------------------------------------------------
 438
 439 Cursor& Cursor::operator=( const Cursor& rCursor )
 440 {
 441     maPos                       = rCursor.maPos;
 442     maSize                      = rCursor.maSize;
 443     mnSlant             = rCursor.mnSlant;
 444     mnOrientation       = rCursor.mnOrientation;
 445     mnDirection         = rCursor.mnDirection;
 446     mbVisible           = rCursor.mbVisible;
 447     ImplNew();
 448
 449     return *this;
 450 }
 451
 452 // -----------------------------------------------------------------------
 453
 454 BOOL Cursor::operator==( const Cursor& rCursor ) const
 455 {
 456     if ( (maPos                 == rCursor.maPos)                       &&
 457          (maSize                == rCursor.maSize)                      &&
 458          (mnSlant               == rCursor.mnSlant)             &&
 459          (mnOrientation == rCursor.mnOrientation)       &&
 460          (mnDirection   == rCursor.mnDirection)     &&
 461          (mbVisible     == rCursor.mbVisible) )
 462         return TRUE;
 463     else
 464         return FALSE;
 465 }