vcl/source/control/ctrl.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
  21 #include <comphelper/processfactory.hxx>
  22
  23 #include <tools/rc.h>
  24 #include <vcl/svapp.hxx>
  25 #include <vcl/event.hxx>
  26 #include <vcl/ctrl.hxx>
  27 #include <vcl/decoview.hxx>
  28 #include <vcl/salnativewidgets.hxx>
  29
  30 #include <textlayout.hxx>
  31 #include <svdata.hxx>
  32 #include <controldata.hxx>
  33
  34
  35 using namespace vcl;
  36
  37 // =======================================================================
  38
  39 void Control::ImplInitControlData()
  40 {
  41     mbHasControlFocus       = sal_False;
  42     mpControlData   = new ImplControlData;
  43 }
  44
  45 // -----------------------------------------------------------------------
  46
  47 Control::Control( WindowType nType ) :
  48     Window( nType )
  49 {
  50     ImplInitControlData();
  51 }
  52
  53 // -----------------------------------------------------------------------
  54
  55 Control::Control( Window* pParent, WinBits nStyle ) :
  56     Window( WINDOW_CONTROL )
  57 {
  58     ImplInitControlData();
  59     ImplInit( pParent, nStyle, NULL );
  60 }
  61
  62 Control::Control( Window* pParent, const ResId& rResId ) :
  63     Window( WINDOW_CONTROL )
  64 {
  65     ImplInitControlData();
  66     rResId.SetRT( RSC_CONTROL );
  67     WinBits nStyle = ImplInitRes( rResId );
  68     ImplInit( pParent, nStyle, NULL );
  69     ImplLoadRes( rResId );
  70
  71     if ( !(nStyle & WB_HIDE) )
  72         Show();
  73 }
  74
  75 // -----------------------------------------------------------------------
  76
  77 Control::~Control()
  78 {
  79     delete mpControlData, mpControlData = NULL;
  80 }
  81
  82 // -----------------------------------------------------------------------
  83
  84 void Control::GetFocus()
  85 {
  86     Window::GetFocus();
  87 }
  88
  89 // -----------------------------------------------------------------------
  90
  91 void Control::LoseFocus()
  92 {
  93     Window::LoseFocus();
  94 }
  95
  96 // -----------------------------------------------------------------------
  97
  98 void Control::Resize()
  99 {
 100     ImplClearLayoutData();
 101     Window::Resize();
 102 }
 103
 104 // -----------------------------------------------------------------------
 105
 106 void Control::FillLayoutData() const
 107 {
 108 }
 109
 110 // -----------------------------------------------------------------------
 111
 112 void Control::CreateLayoutData() const
 113 {
 114     DBG_ASSERT( !mpControlData->mpLayoutData, "Control::CreateLayoutData: should be called with non-existent layout data only!" );
 115     mpControlData->mpLayoutData = new ::vcl::ControlLayoutData();
 116 }
 117
 118 // -----------------------------------------------------------------------
 119
 120 bool Control::HasLayoutData() const
 121 {
 122     return mpControlData->mpLayoutData != NULL;
 123 }
 124
 125 // -----------------------------------------------------------------------
 126
 127 ::vcl::ControlLayoutData* Control::GetLayoutData() const
 128 {
 129     return mpControlData->mpLayoutData;
 130 }
 131
 132 // -----------------------------------------------------------------------
 133
 134 void Control::SetText( const OUString& rStr )
 135 {
 136     ImplClearLayoutData();
 137     Window::SetText( rStr );
 138 }
 139
 140 // -----------------------------------------------------------------------
 141
 142 Rectangle ControlLayoutData::GetCharacterBounds( long nIndex ) const
 143 {
 144     return (nIndex >= 0 && nIndex < (long) m_aUnicodeBoundRects.size()) ? m_aUnicodeBoundRects[ nIndex ] : Rectangle();
 145 }
 146
 147
 148 // -----------------------------------------------------------------------
 149
 150 Rectangle Control::GetCharacterBounds( long nIndex ) const
 151 {
 152     if( !HasLayoutData() )
 153         FillLayoutData();
 154     return mpControlData->mpLayoutData ? mpControlData->mpLayoutData->GetCharacterBounds( nIndex ) : Rectangle();
 155 }
 156
 157 // -----------------------------------------------------------------------
 158
 159 long ControlLayoutData::GetIndexForPoint( const Point& rPoint ) const
 160 {
 161     long nIndex = -1;
 162     for( long i = m_aUnicodeBoundRects.size()-1; i >= 0; i-- )
 163     {
 164         Point aTopLeft = m_aUnicodeBoundRects[i].TopLeft();
 165         Point aBottomRight = m_aUnicodeBoundRects[i].BottomRight();
 166         if (rPoint.X() >= aTopLeft.X() && rPoint.Y() >= aTopLeft.Y() &&
 167             rPoint.X() <= aBottomRight.X() && rPoint.Y() <= aBottomRight.Y())
 168         {
 169             nIndex = i;
 170             break;
 171         }
 172     }
 173     return nIndex;
 174 }
 175
 176 // -----------------------------------------------------------------------
 177
 178 long Control::GetIndexForPoint( const Point& rPoint ) const
 179 {
 180     if( ! HasLayoutData() )
 181         FillLayoutData();
 182     return mpControlData->mpLayoutData ? mpControlData->mpLayoutData->GetIndexForPoint( rPoint ) : -1;
 183 }
 184
 185 // -----------------------------------------------------------------------
 186
 187 long ControlLayoutData::GetLineCount() const
 188 {
 189     long nLines = m_aLineIndices.size();
 190     if( nLines == 0 && !m_aDisplayText.isEmpty() )
 191         nLines = 1;
 192     return nLines;
 193 }
 194
 195 // -----------------------------------------------------------------------
 196
 197 Pair ControlLayoutData::GetLineStartEnd( long nLine ) const
 198 {
 199     Pair aPair( -1, -1 );
 200
 201     int nDisplayLines = m_aLineIndices.size();
 202     if( nLine >= 0 && nLine < nDisplayLines )
 203     {
 204         aPair.A() = m_aLineIndices[nLine];
 205         if( nLine+1 < nDisplayLines )
 206             aPair.B() = m_aLineIndices[nLine+1]-1;
 207         else
 208             aPair.B() = m_aDisplayText.getLength()-1;
 209     }
 210     else if( nLine == 0 && nDisplayLines == 0 && !m_aDisplayText.isEmpty() )
 211     {
 212         // special case for single line controls so the implementations
 213         // in that case do not have to fill in the line indices
 214         aPair.A() = 0;
 215         aPair.B() = m_aDisplayText.getLength()-1;
 216     }
 217     return aPair;
 218 }
 219
 220 // -----------------------------------------------------------------------
 221
 222 Pair Control::GetLineStartEnd( long nLine ) const
 223 {
 224     if( !HasLayoutData() )
 225         FillLayoutData();
 226     return mpControlData->mpLayoutData ? mpControlData->mpLayoutData->GetLineStartEnd( nLine ) : Pair( -1, -1 );
 227 }
 228
 229 // -----------------------------------------------------------------------
 230
 231 long ControlLayoutData::ToRelativeLineIndex( long nIndex ) const
 232 {
 233     // is the index sensible at all ?
 234     if( nIndex >= 0 && nIndex < m_aDisplayText.getLength() )
 235     {
 236         int nDisplayLines = m_aLineIndices.size();
 237         // if only 1 line exists, then absolute and relative index are
 238         // identical -> do nothing
 239         if( nDisplayLines > 1 )
 240         {
 241             int nLine;
 242             for( nLine = nDisplayLines-1; nLine >= 0; nLine-- )
 243             {
 244                 if( m_aLineIndices[nLine] <= nIndex )
 245                 {
 246                     nIndex -= m_aLineIndices[nLine];
 247                     break;
 248                 }
 249             }
 250             if( nLine < 0 )
 251             {
 252                 DBG_ASSERT( nLine >= 0, "ToRelativeLineIndex failed" );
 253                 nIndex = -1;
 254             }
 255         }
 256     }
 257     else
 258         nIndex = -1;
 259
 260     return nIndex;
 261 }
 262
 263 // -----------------------------------------------------------------------
 264
 265 long Control::ToRelativeLineIndex( long nIndex ) const
 266 {
 267     if( !HasLayoutData() )
 268         FillLayoutData();
 269     return mpControlData->mpLayoutData ? mpControlData->mpLayoutData->ToRelativeLineIndex( nIndex ) : -1;
 270 }
 271
 272 // -----------------------------------------------------------------------
 273
 274 OUString Control::GetDisplayText() const
 275 {
 276     if( !HasLayoutData() )
 277         FillLayoutData();
 278     return mpControlData->mpLayoutData ? OUString(mpControlData->mpLayoutData->m_aDisplayText) : GetText();
 279 }
 280
 281 // -----------------------------------------------------------------------
 282
 283 long Control::Notify( NotifyEvent& rNEvt )
 284 {
 285     if ( rNEvt.GetType() == EVENT_GETFOCUS )
 286     {
 287         if ( !mbHasControlFocus )
 288         {
 289             mbHasControlFocus = sal_True;
 290             StateChanged( STATE_CHANGE_CONTROL_FOCUS );
 291             if ( ImplCallEventListenersAndHandler( VCLEVENT_CONTROL_GETFOCUS, maGetFocusHdl, this ) )
 292                 // been destroyed within the handler
 293                 return sal_True;
 294         }
 295     }
 296     else
 297     {
 298         if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
 299         {
 300             Window* pFocusWin = Application::GetFocusWindow();
 301             if ( !pFocusWin || !ImplIsWindowOrChild( pFocusWin ) )
 302             {
 303                 mbHasControlFocus = sal_False;
 304                 StateChanged( STATE_CHANGE_CONTROL_FOCUS );
 305                 if ( ImplCallEventListenersAndHandler( VCLEVENT_CONTROL_LOSEFOCUS, maLoseFocusHdl, this ) )
 306                     // been destroyed within the handler
 307                     return sal_True;
 308             }
 309         }
 310     }
 311
 312     return Window::Notify( rNEvt );
 313 }
 314
 315 // -----------------------------------------------------------------------
 316
 317 void Control::StateChanged( StateChangedType nStateChange )
 318 {
 319     if( nStateChange == STATE_CHANGE_INITSHOW   ||
 320         nStateChange == STATE_CHANGE_VISIBLE    ||
 321         nStateChange == STATE_CHANGE_ZOOM       ||
 322         nStateChange == STATE_CHANGE_BORDER     ||
 323         nStateChange == STATE_CHANGE_CONTROLFONT
 324         )
 325     {
 326         ImplClearLayoutData();
 327     }
 328     Window::StateChanged( nStateChange );
 329 }
 330
 331 // -----------------------------------------------------------------------
 332
 333 void Control::AppendLayoutData( const Control& rSubControl ) const
 334 {
 335     if( !rSubControl.HasLayoutData() )
 336         rSubControl.FillLayoutData();
 337     if( !rSubControl.HasLayoutData() || rSubControl.mpControlData->mpLayoutData->m_aDisplayText.isEmpty() )
 338         return;
 339
 340     long nCurrentIndex = mpControlData->mpLayoutData->m_aDisplayText.getLength();
 341     mpControlData->mpLayoutData->m_aDisplayText += rSubControl.mpControlData->mpLayoutData->m_aDisplayText;
 342     int nLines = rSubControl.mpControlData->mpLayoutData->m_aLineIndices.size();
 343     int n;
 344     mpControlData->mpLayoutData->m_aLineIndices.push_back( nCurrentIndex );
 345     for( n = 1; n < nLines; n++ )
 346         mpControlData->mpLayoutData->m_aLineIndices.push_back( rSubControl.mpControlData->mpLayoutData->m_aLineIndices[n] + nCurrentIndex );
 347     int nRectangles = rSubControl.mpControlData->mpLayoutData->m_aUnicodeBoundRects.size();
 348         Rectangle aRel = const_cast<Control&>(rSubControl).GetWindowExtentsRelative( const_cast<Control*>(this) );
 349     for( n = 0; n < nRectangles; n++ )
 350     {
 351         Rectangle aRect = rSubControl.mpControlData->mpLayoutData->m_aUnicodeBoundRects[n];
 352         aRect.Move( aRel.Left(), aRel.Top() );
 353         mpControlData->mpLayoutData->m_aUnicodeBoundRects.push_back( aRect );
 354     }
 355 }
 356
 357 // -----------------------------------------------------------------
 358
 359 sal_Bool Control::ImplCallEventListenersAndHandler(  sal_uLong nEvent, const Link& rHandler, void* pCaller )
 360 {
 361     ImplDelData aCheckDelete;
 362     ImplAddDel( &aCheckDelete );
 363
 364     ImplCallEventListeners( nEvent );
 365     if ( !aCheckDelete.IsDead() )
 366     {
 367         rHandler.Call( pCaller );
 368
 369         if ( !aCheckDelete.IsDead() )
 370         {
 371             ImplRemoveDel( &aCheckDelete );
 372             return sal_False;
 373         }
 374     }
 375     return sal_True;
 376 }
 377
 378 // -----------------------------------------------------------------
 379
 380 void Control::SetLayoutDataParent( const Control* pParent ) const
 381 {
 382     if( HasLayoutData() )
 383         mpControlData->mpLayoutData->m_pParent = pParent;
 384 }
 385
 386 // -----------------------------------------------------------------
 387
 388 void Control::ImplClearLayoutData() const
 389 {
 390     delete mpControlData->mpLayoutData, mpControlData->mpLayoutData = NULL;
 391 }
 392
 393 // -----------------------------------------------------------------------
 394
 395 void Control::ImplDrawFrame( OutputDevice* pDev, Rectangle& rRect )
 396 {
 397     // use a deco view to draw the frame
 398     // However, since there happens a lot of magic there, we need to fake some (style) settings
 399     // on the device
 400     AllSettings aOriginalSettings( pDev->GetSettings() );
 401
 402     AllSettings aNewSettings( aOriginalSettings );
 403     StyleSettings aStyle( aNewSettings.GetStyleSettings() );
 404
 405     // The *only known* clients of the Draw methods of the various VCL-controls are form controls:
 406     // During print preview, and during printing, Draw is called. Thus, drawing always happens with a
 407     // mono (colored) border
 408     aStyle.SetOptions( aStyle.GetOptions() | STYLE_OPTION_MONO );
 409     aStyle.SetMonoColor( GetSettings().GetStyleSettings().GetMonoColor() );
 410
 411     aNewSettings.SetStyleSettings( aStyle );
 412     // #i67023# do not call data changed listeners for this fake
 413     // since they may understandably invalidate on settings changed
 414     pDev->OutputDevice::SetSettings( aNewSettings );
 415
 416     DecorationView aDecoView( pDev );
 417     rRect = aDecoView.DrawFrame( rRect, FRAME_DRAW_WINDOWBORDER );
 418
 419     pDev->OutputDevice::SetSettings( aOriginalSettings );
 420 }
 421
 422 // -----------------------------------------------------------------------
 423
 424 void Control::DataChanged( const DataChangedEvent& rDCEvt)
 425 {
 426     // we don't want to loose some style settings for controls created with the
 427     // toolkit
 428     if ( IsCreatedWithToolkit() &&
 429          (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 430          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 431     {
 432         const AllSettings* pOldSettings = rDCEvt.GetOldSettings();
 433
 434         AllSettings aSettings = GetSettings();
 435         StyleSettings aStyleSettings = aSettings.GetStyleSettings();
 436         sal_uLong nNewOptions = aStyleSettings.GetOptions();
 437
 438         if ( pOldSettings && !(nNewOptions & STYLE_OPTION_MONO) && ( pOldSettings->GetStyleSettings().GetOptions() & STYLE_OPTION_MONO ) )
 439         {
 440             nNewOptions |= STYLE_OPTION_MONO;
 441             aStyleSettings.SetOptions( nNewOptions );
 442             aStyleSettings.SetMonoColor( pOldSettings->GetStyleSettings().GetMonoColor() );
 443             aSettings.SetStyleSettings( aStyleSettings );
 444             SetSettings( aSettings );
 445         }
 446     }
 447 }
 448
 449 // -----------------------------------------------------------------
 450
 451 ControlLayoutData::~ControlLayoutData()
 452 {
 453     if( m_pParent )
 454         m_pParent->ImplClearLayoutData();
 455 }
 456
 457 // -----------------------------------------------------------------
 458
 459 Size Control::GetOptimalSize() const
 460 {
 461     return Size( GetTextWidth( GetText() ) + 2 * 12,
 462                  GetTextHeight() + 2 * 6 );
 463 }
 464
 465 // -----------------------------------------------------------------
 466
 467 void Control::SetReferenceDevice( OutputDevice* _referenceDevice )
 468 {
 469     if ( mpControlData->mpReferenceDevice == _referenceDevice )
 470         return;
 471
 472     mpControlData->mpReferenceDevice = _referenceDevice;
 473     Invalidate();
 474 }
 475
 476 // -----------------------------------------------------------------
 477
 478 OutputDevice* Control::GetReferenceDevice() const
 479 {
 480     return mpControlData->mpReferenceDevice;
 481 }
 482
 483 // -----------------------------------------------------------------
 484
 485 const Font& Control::GetCanonicalFont( const StyleSettings& _rStyle ) const
 486 {
 487     return _rStyle.GetLabelFont();
 488 }
 489
 490 // -----------------------------------------------------------------
 491 const Color& Control::GetCanonicalTextColor( const StyleSettings& _rStyle ) const
 492 {
 493     return _rStyle.GetLabelTextColor();
 494 }
 495
 496 // -----------------------------------------------------------------
 497 void Control::ImplInitSettings( const sal_Bool _bFont, const sal_Bool _bForeground )
 498 {
 499     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 500
 501     if ( _bFont )
 502     {
 503         Font aFont( GetCanonicalFont( rStyleSettings ) );
 504         if ( IsControlFont() )
 505             aFont.Merge( GetControlFont() );
 506         SetZoomedPointFont( aFont );
 507     }
 508
 509     if ( _bForeground || _bFont )
 510     {
 511         Color aColor;
 512         if ( IsControlForeground() )
 513             aColor = GetControlForeground();
 514         else
 515             aColor = GetCanonicalTextColor( rStyleSettings );
 516         SetTextColor( aColor );
 517         SetTextFillColor();
 518     }
 519 }
 520
 521 // -----------------------------------------------------------------
 522
 523 void Control::DrawControlText( OutputDevice& _rTargetDevice, Rectangle& _io_rRect, const OUString& _rStr,
 524     sal_uInt16 _nStyle, MetricVector* _pVector, OUString* _pDisplayText ) const
 525 {
 526 #ifdef FS_DEBUG
 527     if ( !_pVector )
 528     {
 529         static MetricVector aCharRects;
 530         static String sDisplayText;
 531         aCharRects.clear();
 532         sDisplayText = String();
 533         _pVector = &aCharRects;
 534         _pDisplayText = &sDisplayText;
 535     }
 536 #endif
 537
 538     if ( !mpControlData->mpReferenceDevice || ( mpControlData->mpReferenceDevice == &_rTargetDevice ) )
 539     {
 540         _io_rRect = _rTargetDevice.GetTextRect( _io_rRect, _rStr, _nStyle );
 541         _rTargetDevice.DrawText( _io_rRect, _rStr, _nStyle, _pVector, _pDisplayText );
 542     }
 543     else
 544     {
 545         ControlTextRenderer aRenderer( *this, _rTargetDevice, *mpControlData->mpReferenceDevice );
 546         _io_rRect = aRenderer.DrawText( _io_rRect, _rStr, _nStyle, _pVector, _pDisplayText );
 547     }
 548
 549 #ifdef FS_DEBUG
 550     _rTargetDevice.Push( PUSH_LINECOLOR | PUSH_FILLCOLOR );
 551     _rTargetDevice.SetLineColor( COL_LIGHTRED );
 552     _rTargetDevice.SetFillColor();
 553     for (   MetricVector::const_iterator cr = _pVector->begin();
 554             cr != _pVector->end();
 555             ++cr
 556         )
 557     {
 558         _rTargetDevice.DrawRect( *cr );
 559     }
 560     _rTargetDevice.Pop();
 561 #endif
 562 }
 563
 564 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */