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 #include <comphelper/lok.hxx>
  21 #include <o3tl/safeint.hxx>
  22 #include <vcl/svapp.hxx>
  23 #include <vcl/event.hxx>
  24 #include <vcl/ctrl.hxx>
  25 #include <vcl/decoview.hxx>
  26 #include <vcl/mnemonic.hxx>
  27 #include <vcl/settings.hxx>
  28 #include <vcl/uitest/logger.hxx>
  29 #include <vcl/DocWindow.hxx>
  30 #include <sal/log.hxx>
  31
  32 #include <textlayout.hxx>
  33 #include <svdata.hxx>
  34
  35 using namespace vcl;
  36
  37 void Control::ImplInitControlData()
  38 {
  39     mbHasControlFocus       = false;
  40     mbShowAccelerator       = false;
  41 }
  42
  43 Control::Control( WindowType nType ) :
  44     Window( nType )
  45 {
  46     ImplInitControlData();
  47 }
  48
  49 Control::Control( vcl::Window* pParent, WinBits nStyle ) :
  50     Window( WindowType::CONTROL )
  51 {
  52     ImplInitControlData();
  53     ImplInit( pParent, nStyle, nullptr );
  54 }
  55
  56 Control::~Control()
  57 {
  58     disposeOnce();
  59 }
  60
  61 void Control::dispose()
  62 {
  63     mxLayoutData.reset();
  64     mpReferenceDevice.clear();
  65     Window::dispose();
  66 }
  67
  68 void Control::EnableRTL( bool bEnable )
  69 {
  70     // convenience: for controls also switch layout mode
  71     GetOutDev()->SetLayoutMode( bEnable ? vcl::text::ComplexTextLayoutFlags::BiDiRtl | vcl::text::ComplexTextLayoutFlags::TextOriginLeft :
  72                                 vcl::text::ComplexTextLayoutFlags::TextOriginLeft );
  73     CompatStateChanged( StateChangedType::Mirroring );
  74     Window::EnableRTL(bEnable);
  75 }
  76
  77 void Control::Resize()
  78 {
  79     ImplClearLayoutData();
  80     Window::Resize();
  81 }
  82
  83 void Control::FillLayoutData() const
  84 {
  85 }
  86
  87 void Control::CreateLayoutData() const
  88 {
  89     SAL_WARN_IF( mxLayoutData, "vcl", "Control::CreateLayoutData: should be called with non-existent layout data only!" );
  90     mxLayoutData.emplace();
  91 }
  92
  93 bool Control::HasLayoutData() const
  94 {
  95     return bool(mxLayoutData);
  96 }
  97
  98 void Control::SetText( const OUString& rStr )
  99 {
 100     ImplClearLayoutData();
 101     Window::SetText( rStr );
 102 }
 103
 104 ControlLayoutData::ControlLayoutData() : m_pParent( nullptr )
 105 {
 106 }
 107
 108 tools::Rectangle ControlLayoutData::GetCharacterBounds( tools::Long nIndex ) const
 109 {
 110     return (nIndex >= 0 && o3tl::make_unsigned(nIndex) < m_aUnicodeBoundRects.size()) ? m_aUnicodeBoundRects[ nIndex ] : tools::Rectangle();
 111 }
 112
 113 tools::Rectangle Control::GetCharacterBounds( tools::Long nIndex ) const
 114 {
 115     if( !HasLayoutData() )
 116         FillLayoutData();
 117     return mxLayoutData ? mxLayoutData->GetCharacterBounds( nIndex ) : tools::Rectangle();
 118 }
 119
 120 tools::Long ControlLayoutData::GetIndexForPoint( const Point& rPoint ) const
 121 {
 122     tools::Long nIndex = -1;
 123     for( tools::Long i = m_aUnicodeBoundRects.size()-1; i >= 0; i-- )
 124     {
 125         Point aTopLeft = m_aUnicodeBoundRects[i].TopLeft();
 126         Point aBottomRight = m_aUnicodeBoundRects[i].BottomRight();
 127         if (rPoint.X() >= aTopLeft.X() && rPoint.Y() >= aTopLeft.Y() &&
 128             rPoint.X() <= aBottomRight.X() && rPoint.Y() <= aBottomRight.Y())
 129         {
 130             nIndex = i;
 131             break;
 132         }
 133     }
 134     return nIndex;
 135 }
 136
 137 tools::Long Control::GetIndexForPoint( const Point& rPoint ) const
 138 {
 139     if( ! HasLayoutData() )
 140         FillLayoutData();
 141     return mxLayoutData ? mxLayoutData->GetIndexForPoint( rPoint ) : -1;
 142 }
 143
 144 tools::Long ControlLayoutData::GetLineCount() const
 145 {
 146     tools::Long nLines = m_aLineIndices.size();
 147     if( nLines == 0 && !m_aDisplayText.isEmpty() )
 148         nLines = 1;
 149     return nLines;
 150 }
 151
 152 Pair ControlLayoutData::GetLineStartEnd( tools::Long nLine ) const
 153 {
 154     Pair aPair( -1, -1 );
 155
 156     int nDisplayLines = m_aLineIndices.size();
 157     if( nLine >= 0 && nLine < nDisplayLines )
 158     {
 159         aPair.A() = m_aLineIndices[nLine];
 160         if( nLine+1 < nDisplayLines )
 161             aPair.B() = m_aLineIndices[nLine+1]-1;
 162         else
 163             aPair.B() = m_aDisplayText.getLength()-1;
 164     }
 165     else if( nLine == 0 && nDisplayLines == 0 && !m_aDisplayText.isEmpty() )
 166     {
 167         // special case for single line controls so the implementations
 168         // in that case do not have to fill in the line indices
 169         aPair.A() = 0;
 170         aPair.B() = m_aDisplayText.getLength()-1;
 171     }
 172     return aPair;
 173 }
 174
 175 Pair Control::GetLineStartEnd( tools::Long nLine ) const
 176 {
 177     if( !HasLayoutData() )
 178         FillLayoutData();
 179     return mxLayoutData ? mxLayoutData->GetLineStartEnd( nLine ) : Pair( -1, -1 );
 180 }
 181
 182 tools::Long ControlLayoutData::ToRelativeLineIndex( tools::Long nIndex ) const
 183 {
 184     // is the index sensible at all ?
 185     if( nIndex >= 0 && nIndex < m_aDisplayText.getLength() )
 186     {
 187         int nDisplayLines = m_aLineIndices.size();
 188         // if only 1 line exists, then absolute and relative index are
 189         // identical -> do nothing
 190         if( nDisplayLines > 1 )
 191         {
 192             int nLine;
 193             for( nLine = nDisplayLines-1; nLine >= 0; nLine-- )
 194             {
 195                 if( m_aLineIndices[nLine] <= nIndex )
 196                 {
 197                     nIndex -= m_aLineIndices[nLine];
 198                     break;
 199                 }
 200             }
 201             if( nLine < 0 )
 202             {
 203                 SAL_WARN_IF( nLine < 0, "vcl", "ToRelativeLineIndex failed" );
 204                 nIndex = -1;
 205             }
 206         }
 207     }
 208     else
 209         nIndex = -1;
 210
 211     return nIndex;
 212 }
 213
 214 tools::Long Control::ToRelativeLineIndex( tools::Long nIndex ) const
 215 {
 216     if( !HasLayoutData() )
 217         FillLayoutData();
 218     return mxLayoutData ? mxLayoutData->ToRelativeLineIndex( nIndex ) : -1;
 219 }
 220
 221 OUString Control::GetDisplayText() const
 222 {
 223     if( !HasLayoutData() )
 224         FillLayoutData();
 225     return mxLayoutData ? mxLayoutData->m_aDisplayText : GetText();
 226 }
 227
 228 bool Control::FocusWindowBelongsToControl(const vcl::Window* pFocusWin) const
 229 {
 230     return ImplIsWindowOrChild(pFocusWin);
 231 }
 232
 233 bool Control::EventNotify( NotifyEvent& rNEvt )
 234 {
 235     if ( rNEvt.GetType() == NotifyEventType::GETFOCUS )
 236     {
 237         if ( !mbHasControlFocus )
 238         {
 239             mbHasControlFocus = true;
 240             CompatStateChanged( StateChangedType::ControlFocus );
 241             if ( ImplCallEventListenersAndHandler( VclEventId::ControlGetFocus, {} ) )
 242                 // been destroyed within the handler
 243                 return true;
 244         }
 245     }
 246     else
 247     {
 248         if ( rNEvt.GetType() == NotifyEventType::LOSEFOCUS )
 249         {
 250             vcl::Window* pFocusWin = Application::GetFocusWindow();
 251             if ( !pFocusWin || !FocusWindowBelongsToControl(pFocusWin) )
 252             {
 253                 mbHasControlFocus = false;
 254                 CompatStateChanged( StateChangedType::ControlFocus );
 255                 if ( ImplCallEventListenersAndHandler( VclEventId::ControlLoseFocus, [this] () { maLoseFocusHdl.Call(*this); } ) )
 256                     // been destroyed within the handler
 257                     return true;
 258             }
 259         }
 260     }
 261     return Window::EventNotify( rNEvt );
 262 }
 263
 264 void Control::StateChanged( StateChangedType nStateChange )
 265 {
 266     if( nStateChange == StateChangedType::InitShow   ||
 267         nStateChange == StateChangedType::Visible    ||
 268         nStateChange == StateChangedType::Zoom       ||
 269         nStateChange == StateChangedType::ControlFont
 270         )
 271     {
 272         ImplClearLayoutData();
 273     }
 274     Window::StateChanged( nStateChange );
 275 }
 276
 277 void Control::AppendLayoutData( const Control& rSubControl ) const
 278 {
 279     if( !rSubControl.HasLayoutData() )
 280         rSubControl.FillLayoutData();
 281     if( !rSubControl.HasLayoutData() || rSubControl.mxLayoutData->m_aDisplayText.isEmpty() )
 282         return;
 283
 284     tools::Long nCurrentIndex = mxLayoutData->m_aDisplayText.getLength();
 285     mxLayoutData->m_aDisplayText += rSubControl.mxLayoutData->m_aDisplayText;
 286     int nLines = rSubControl.mxLayoutData->m_aLineIndices.size();
 287     int n;
 288     mxLayoutData->m_aLineIndices.push_back( nCurrentIndex );
 289     for( n = 1; n < nLines; n++ )
 290         mxLayoutData->m_aLineIndices.push_back( rSubControl.mxLayoutData->m_aLineIndices[n] + nCurrentIndex );
 291     int nRectangles = rSubControl.mxLayoutData->m_aUnicodeBoundRects.size();
 292     tools::Rectangle aRel = rSubControl.GetWindowExtentsRelative(this);
 293     for( n = 0; n < nRectangles; n++ )
 294     {
 295         tools::Rectangle aRect = rSubControl.mxLayoutData->m_aUnicodeBoundRects[n];
 296         aRect.Move( aRel.Left(), aRel.Top() );
 297         mxLayoutData->m_aUnicodeBoundRects.push_back( aRect );
 298     }
 299 }
 300
 301 void Control::CallEventListeners( VclEventId nEvent, void* pData)
 302 {
 303     VclPtr<Control> xThis(this);
 304     UITestLogger::getInstance().logAction(xThis, nEvent);
 305
 306     vcl::Window::CallEventListeners(nEvent, pData);
 307 }
 308
 309 bool Control::ImplCallEventListenersAndHandler( VclEventId nEvent, std::function<void()> const & callHandler )
 310 {
 311     VclPtr<Control> xThis(this);
 312
 313     Control::CallEventListeners( nEvent );
 314
 315     if ( !xThis->isDisposed() )
 316     {
 317         if (callHandler)
 318         {
 319             callHandler();
 320         }
 321
 322         if ( !xThis->isDisposed() )
 323             return false;
 324     }
 325     return true;
 326 }
 327
 328 void Control::SetLayoutDataParent( const Control* pParent ) const
 329 {
 330     if( HasLayoutData() )
 331         mxLayoutData->m_pParent = pParent;
 332 }
 333
 334 void Control::ImplClearLayoutData() const
 335 {
 336     mxLayoutData.reset();
 337 }
 338
 339 void Control::ImplDrawFrame( OutputDevice* pDev, tools::Rectangle& rRect )
 340 {
 341     // use a deco view to draw the frame
 342     // However, since there happens a lot of magic there, we need to fake some (style) settings
 343     // on the device
 344     AllSettings aOriginalSettings( pDev->GetSettings() );
 345
 346     AllSettings aNewSettings( aOriginalSettings );
 347     StyleSettings aStyle( aNewSettings.GetStyleSettings() );
 348
 349     // The *only known* clients of the Draw methods of the various VCL-controls are form controls:
 350     // During print preview, and during printing, Draw is called. Thus, drawing always happens with a
 351     // mono (colored) border
 352     aStyle.SetOptions( aStyle.GetOptions() | StyleSettingsOptions::Mono );
 353     aStyle.SetMonoColor( GetSettings().GetStyleSettings().GetMonoColor() );
 354
 355     aNewSettings.SetStyleSettings( aStyle );
 356     // #i67023# do not call data changed listeners for this fake
 357     // since they may understandably invalidate on settings changed
 358     pDev->OutputDevice::SetSettings( aNewSettings );
 359
 360     DecorationView aDecoView( pDev );
 361     rRect = aDecoView.DrawFrame( rRect, DrawFrameStyle::Out, DrawFrameFlags::WindowBorder );
 362
 363     pDev->OutputDevice::SetSettings( aOriginalSettings );
 364 }
 365
 366 void Control::SetShowAccelerator(bool bVal)
 367 {
 368     mbShowAccelerator = bVal;
 369 };
 370
 371 ControlLayoutData::~ControlLayoutData()
 372 {
 373     if( m_pParent )
 374         m_pParent->ImplClearLayoutData();
 375 }
 376
 377 Size Control::GetOptimalSize() const
 378 {
 379     return Size( GetTextWidth( GetText() ) + 2 * 12,
 380                  GetTextHeight() + 2 * 6 );
 381 }
 382
 383 void Control::SetReferenceDevice( OutputDevice* _referenceDevice )
 384 {
 385     if ( mpReferenceDevice == _referenceDevice )
 386         return;
 387
 388     mpReferenceDevice = _referenceDevice;
 389     Invalidate();
 390 }
 391
 392 OutputDevice* Control::GetReferenceDevice() const
 393 {
 394     // tdf#118377 It can happen that mpReferenceDevice is already disposed and
 395     // stays disposed (see task, even when Dialog is closed). I have no idea if
 396     // this may be very bad - someone who knows more about lifetime of OutputDevice's
 397     // will have to decide.
 398     // To secure this, I changed all accesses to mpControlData->mpReferenceDevice to
 399     // use Control::GetReferenceDevice() - only use mpControlData->mpReferenceDevice
 400     // inside Control::SetReferenceDevice and Control::GetReferenceDevice().
 401     // Control::GetReferenceDevice() will now reset mpReferenceDevice if it is already
 402     // disposed. This way all usages will do a kind of 'test-and-get' call.
 403     if(nullptr != mpReferenceDevice && mpReferenceDevice->isDisposed())
 404     {
 405         const_cast<Control*>(this)->SetReferenceDevice(nullptr);
 406     }
 407
 408     return mpReferenceDevice;
 409 }
 410
 411 const vcl::Font& Control::GetCanonicalFont( const StyleSettings& _rStyle ) const
 412 {
 413     return _rStyle.GetLabelFont();
 414 }
 415
 416 const Color& Control::GetCanonicalTextColor( const StyleSettings& _rStyle ) const
 417 {
 418     return _rStyle.GetLabelTextColor();
 419 }
 420
 421 void Control::ApplySettings(vcl::RenderContext& rRenderContext)
 422 {
 423     const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
 424
 425     ApplyControlFont(rRenderContext, GetCanonicalFont(rStyleSettings));
 426
 427     ApplyControlForeground(rRenderContext, GetCanonicalTextColor(rStyleSettings));
 428     rRenderContext.SetTextFillColor();
 429 }
 430
 431 void Control::ImplInitSettings()
 432 {
 433     ApplySettings(*GetOutDev());
 434 }
 435
 436 tools::Rectangle Control::DrawControlText( OutputDevice& _rTargetDevice, const tools::Rectangle& rRect, const OUString& _rStr,
 437     DrawTextFlags _nStyle, std::vector< tools::Rectangle >* _pVector, OUString* _pDisplayText, const Size* i_pDeviceSize ) const
 438 {
 439     OUString rPStr = _rStr;
 440     DrawTextFlags nPStyle = _nStyle;
 441
 442     bool autoacc = ImplGetSVData()->maNWFData.mbAutoAccel;
 443
 444     if (autoacc && !mbShowAccelerator)
 445     {
 446         rPStr = removeMnemonicFromString( _rStr );
 447         nPStyle &= ~DrawTextFlags::HideMnemonic;
 448     }
 449
 450     if( !GetReferenceDevice() || ( GetReferenceDevice() == &_rTargetDevice ) )
 451     {
 452         const tools::Rectangle aRet = _rTargetDevice.GetTextRect(rRect, rPStr, nPStyle);
 453         _rTargetDevice.DrawText(aRet, rPStr, nPStyle, _pVector, _pDisplayText);
 454         return aRet;
 455     }
 456
 457     ControlTextRenderer aRenderer( *this, _rTargetDevice, *GetReferenceDevice() );
 458     return aRenderer.DrawText(rRect, rPStr, nPStyle, _pVector, _pDisplayText, i_pDeviceSize);
 459 }
 460
 461 tools::Rectangle Control::GetControlTextRect( OutputDevice& _rTargetDevice, const tools::Rectangle & rRect,
 462                                        const OUString& _rStr, DrawTextFlags _nStyle, Size* o_pDeviceSize ) const
 463 {
 464     OUString rPStr = _rStr;
 465     DrawTextFlags nPStyle = _nStyle;
 466
 467     bool autoacc = ImplGetSVData()->maNWFData.mbAutoAccel;
 468
 469     if (autoacc && !mbShowAccelerator)
 470     {
 471         rPStr = removeMnemonicFromString( _rStr );
 472         nPStyle &= ~DrawTextFlags::HideMnemonic;
 473     }
 474
 475     if ( !GetReferenceDevice() || ( GetReferenceDevice() == &_rTargetDevice ) )
 476     {
 477         tools::Rectangle aRet = _rTargetDevice.GetTextRect( rRect, rPStr, nPStyle );
 478         if (o_pDeviceSize)
 479         {
 480             *o_pDeviceSize = aRet.GetSize();
 481         }
 482         return aRet;
 483     }
 484
 485     ControlTextRenderer aRenderer( *this, _rTargetDevice, *GetReferenceDevice() );
 486     return aRenderer.GetTextRect(rRect, rPStr, nPStyle, o_pDeviceSize);
 487 }
 488
 489 Font
 490 Control::GetUnzoomedControlPointFont() const
 491 {
 492     Font aFont(GetCanonicalFont(GetSettings().GetStyleSettings()));
 493     if (IsControlFont())
 494         aFont.Merge(GetControlFont());
 495     return aFont;
 496 }
 497
 498 void Control::LogicInvalidate(const tools::Rectangle* pRectangle)
 499 {
 500     VclPtr<vcl::Window> pParent = GetParentWithLOKNotifier();
 501     if (!pParent || !dynamic_cast<vcl::DocWindow*>(GetParent()))
 502     {
 503         // if control doesn't belong to a DocWindow, the overridden base class
 504         // method has to be invoked
 505         Window::LogicInvalidate(pRectangle);
 506         return;
 507     }
 508
 509     // avoid endless paint/invalidate loop in Impress
 510     if (comphelper::LibreOfficeKit::isTiledPainting())
 511         return;
 512
 513     tools::Rectangle aResultRectangle;
 514     if (!pRectangle)
 515     {
 516         // we have to invalidate the whole control area not the whole document
 517         aResultRectangle = tools::Rectangle(GetPosPixel(), GetSizePixel());
 518     }
 519     else
 520     {
 521         aResultRectangle = *pRectangle;
 522     }
 523
 524     aResultRectangle = PixelToLogic(aResultRectangle, MapMode(MapUnit::MapTwip));
 525     pParent->GetLOKNotifier()->notifyInvalidation(&aResultRectangle);
 526 }
 527
 528 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */