vcl/source/control/fixed.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 <vcl/cvtgrf.hxx>
  21 #include <vcl/decoview.hxx>
  22 #include <vcl/event.hxx>
  23 #include <vcl/toolkit/fixed.hxx>
  24 #include <vcl/settings.hxx>
  25
  26 #include <comphelper/base64.hxx>
  27 #include <comphelper/string.hxx>
  28 #include <sal/log.hxx>
  29 #include <tools/json_writer.hxx>
  30 #include <tools/stream.hxx>
  31
  32 #define FIXEDLINE_TEXT_BORDER    4
  33
  34 constexpr auto FIXEDTEXT_VIEW_STYLE = WB_3DLOOK |
  35                                  WB_LEFT | WB_CENTER | WB_RIGHT |
  36                                  WB_TOP | WB_VCENTER | WB_BOTTOM |
  37                                  WB_WORDBREAK | WB_NOLABEL |
  38                                  WB_PATHELLIPSIS;
  39 constexpr auto FIXEDLINE_VIEW_STYLE = WB_3DLOOK | WB_NOLABEL;
  40 constexpr auto FIXEDBITMAP_VIEW_STYLE = WB_3DLOOK |
  41                                  WB_LEFT | WB_CENTER | WB_RIGHT |
  42                                  WB_TOP | WB_VCENTER | WB_BOTTOM |
  43                                  WB_SCALE;
  44 constexpr auto FIXEDIMAGE_VIEW_STYLE = WB_3DLOOK |
  45                                  WB_LEFT | WB_CENTER | WB_RIGHT |
  46                                  WB_TOP | WB_VCENTER | WB_BOTTOM |
  47                                  WB_SCALE;
  48
  49 static Point ImplCalcPos( WinBits nStyle, const Point& rPos,
  50                           const Size& rObjSize, const Size& rWinSize )
  51 {
  52     tools::Long    nX;
  53     tools::Long    nY;
  54
  55     if ( nStyle & WB_LEFT )
  56         nX = 0;
  57     else if ( nStyle & WB_RIGHT )
  58         nX = rWinSize.Width()-rObjSize.Width();
  59     else
  60         nX = (rWinSize.Width()-rObjSize.Width())/2;
  61
  62     if ( nStyle & WB_TOP )
  63         nY = 0;
  64     else if ( nStyle & WB_BOTTOM )
  65         nY = rWinSize.Height()-rObjSize.Height();
  66     else
  67         nY = (rWinSize.Height()-rObjSize.Height())/2;
  68
  69     Point aPos( nX+rPos.X(), nY+rPos.Y() );
  70     return aPos;
  71 }
  72
  73 void FixedText::ImplInit( vcl::Window* pParent, WinBits nStyle )
  74 {
  75     nStyle = ImplInitStyle( nStyle );
  76     Control::ImplInit( pParent, nStyle, nullptr );
  77     ApplySettings(*GetOutDev());
  78 }
  79
  80 WinBits FixedText::ImplInitStyle( WinBits nStyle )
  81 {
  82     if ( !(nStyle & WB_NOGROUP) )
  83         nStyle |= WB_GROUP;
  84     return nStyle;
  85 }
  86
  87 const vcl::Font& FixedText::GetCanonicalFont( const StyleSettings& _rStyle ) const
  88 {
  89     return _rStyle.GetLabelFont();
  90 }
  91
  92 const Color& FixedText::GetCanonicalTextColor( const StyleSettings& _rStyle ) const
  93 {
  94     return _rStyle.GetLabelTextColor();
  95 }
  96
  97 FixedText::FixedText(vcl::Window* pParent, WinBits nStyle, WindowType eType)
  98     : Control(eType)
  99     , m_nMaxWidthChars(-1)
 100     , m_nMinWidthChars(-1)
 101     , m_pMnemonicWindow(nullptr)
 102 {
 103     ImplInit( pParent, nStyle );
 104 }
 105
 106 DrawTextFlags FixedText::ImplGetTextStyle( WinBits nWinStyle )
 107 {
 108     DrawTextFlags nTextStyle = DrawTextFlags::Mnemonic | DrawTextFlags::EndEllipsis;
 109
 110     if( ! (nWinStyle & WB_NOMULTILINE) )
 111         nTextStyle |= DrawTextFlags::MultiLine;
 112
 113     if ( nWinStyle & WB_RIGHT )
 114         nTextStyle |= DrawTextFlags::Right;
 115     else if ( nWinStyle & WB_CENTER )
 116         nTextStyle |= DrawTextFlags::Center;
 117     else
 118         nTextStyle |= DrawTextFlags::Left;
 119     if ( nWinStyle & WB_BOTTOM )
 120         nTextStyle |= DrawTextFlags::Bottom;
 121     else if ( nWinStyle & WB_VCENTER )
 122         nTextStyle |= DrawTextFlags::VCenter;
 123     else
 124         nTextStyle |= DrawTextFlags::Top;
 125     if ( nWinStyle & WB_WORDBREAK )
 126         nTextStyle |= DrawTextFlags::WordBreak;
 127     if ( nWinStyle & WB_NOLABEL )
 128         nTextStyle &= ~DrawTextFlags::Mnemonic;
 129
 130     return nTextStyle;
 131 }
 132
 133 void FixedText::ImplDraw(OutputDevice* pDev, SystemTextColorFlags nSystemTextColorFlags,
 134                          const Point& rPos, const Size& rSize,
 135                          bool bFillLayout) const
 136 {
 137     const StyleSettings& rStyleSettings = pDev->GetSettings().GetStyleSettings();
 138     WinBits nWinStyle = GetStyle();
 139     OUString aText(GetText());
 140     DrawTextFlags nTextStyle = FixedText::ImplGetTextStyle( nWinStyle );
 141     Point aPos = rPos;
 142
 143     if ( nWinStyle & WB_EXTRAOFFSET )
 144         aPos.AdjustX(2 );
 145
 146     if ( nWinStyle & WB_PATHELLIPSIS )
 147     {
 148         nTextStyle &= ~DrawTextFlags(DrawTextFlags::EndEllipsis | DrawTextFlags::MultiLine | DrawTextFlags::WordBreak);
 149         nTextStyle |= DrawTextFlags::PathEllipsis;
 150     }
 151     if ( !IsEnabled() )
 152         nTextStyle |= DrawTextFlags::Disable;
 153     if ( (nSystemTextColorFlags & SystemTextColorFlags::Mono) ||
 154          (rStyleSettings.GetOptions() & StyleSettingsOptions::Mono) )
 155         nTextStyle |= DrawTextFlags::Mono;
 156
 157     if( bFillLayout )
 158         mxLayoutData->m_aDisplayText.clear();
 159
 160     const tools::Rectangle aRect(aPos, rSize);
 161     DrawControlText(*pDev, aRect, aText, nTextStyle,
 162         bFillLayout ? &mxLayoutData->m_aUnicodeBoundRects : nullptr,
 163         bFillLayout ? &mxLayoutData->m_aDisplayText : nullptr);
 164 }
 165
 166 void FixedText::ApplySettings(vcl::RenderContext& rRenderContext)
 167 {
 168     Control::ApplySettings(rRenderContext);
 169
 170     vcl::Window* pParent = GetParent();
 171     bool bEnableTransparent = true;
 172     if (!pParent->IsChildTransparentModeEnabled() || IsControlBackground())
 173     {
 174         EnableChildTransparentMode(false);
 175         SetParentClipMode();
 176         SetPaintTransparent(false);
 177
 178         if (IsControlBackground())
 179             rRenderContext.SetBackground(GetControlBackground());
 180         else
 181             rRenderContext.SetBackground(pParent->GetBackground());
 182
 183         if (rRenderContext.IsBackground())
 184             bEnableTransparent = false;
 185     }
 186
 187     if (bEnableTransparent)
 188     {
 189         EnableChildTransparentMode();
 190         SetParentClipMode(ParentClipMode::NoClip);
 191         SetPaintTransparent(true);
 192         rRenderContext.SetBackground();
 193     }
 194 }
 195
 196 void FixedText::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& )
 197 {
 198     ImplDraw(&rRenderContext, SystemTextColorFlags::NONE, Point(), GetOutputSizePixel());
 199 }
 200
 201 void FixedText::Draw( OutputDevice* pDev, const Point& rPos,
 202                       SystemTextColorFlags nFlags )
 203 {
 204     ApplySettings(*pDev);
 205
 206     Point       aPos  = pDev->LogicToPixel( rPos );
 207     Size        aSize = GetSizePixel();
 208     vcl::Font   aFont = GetDrawPixelFont( pDev );
 209
 210     pDev->Push();
 211     pDev->SetMapMode();
 212     pDev->SetFont( aFont );
 213     if ( nFlags & SystemTextColorFlags::Mono )
 214         pDev->SetTextColor( COL_BLACK );
 215     else
 216         pDev->SetTextColor( GetTextColor() );
 217     pDev->SetTextFillColor();
 218
 219     bool bBorder = (GetStyle() & WB_BORDER);
 220     bool bBackground = IsControlBackground();
 221     if ( bBorder || bBackground )
 222     {
 223         tools::Rectangle aRect( aPos, aSize );
 224         if ( bBorder )
 225         {
 226             ImplDrawFrame( pDev, aRect );
 227         }
 228         if ( bBackground )
 229         {
 230             pDev->SetFillColor( GetControlBackground() );
 231             pDev->DrawRect( aRect );
 232         }
 233     }
 234
 235     ImplDraw( pDev, nFlags, aPos, aSize );
 236     pDev->Pop();
 237 }
 238
 239 void FixedText::Resize()
 240 {
 241     Control::Resize();
 242     Invalidate();
 243 }
 244
 245 void FixedText::StateChanged( StateChangedType nType )
 246 {
 247     Control::StateChanged( nType );
 248
 249     if ( (nType == StateChangedType::Enable) ||
 250          (nType == StateChangedType::Text) ||
 251          (nType == StateChangedType::UpdateMode) )
 252     {
 253         if ( IsReallyVisible() && IsUpdateMode() )
 254             Invalidate();
 255     }
 256     else if ( nType == StateChangedType::Style )
 257     {
 258         SetStyle( ImplInitStyle( GetStyle() ) );
 259         if ( (GetPrevStyle() & FIXEDTEXT_VIEW_STYLE) !=
 260              (GetStyle() & FIXEDTEXT_VIEW_STYLE) )
 261         {
 262             ApplySettings(*GetOutDev());
 263             Invalidate();
 264         }
 265     }
 266     else if ( (nType == StateChangedType::Zoom)  ||
 267               (nType == StateChangedType::ControlFont) )
 268     {
 269         ApplySettings(*GetOutDev());
 270         Invalidate();
 271     }
 272     else if ( nType == StateChangedType::ControlForeground )
 273     {
 274         ApplySettings(*GetOutDev());
 275         Invalidate();
 276     }
 277     else if ( nType == StateChangedType::ControlBackground )
 278     {
 279         ApplySettings(*GetOutDev());
 280         Invalidate();
 281     }
 282 }
 283
 284 void FixedText::DataChanged( const DataChangedEvent& rDCEvt )
 285 {
 286     Control::DataChanged( rDCEvt );
 287
 288     if ( (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
 289          (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
 290          ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
 291           (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
 292     {
 293         ApplySettings(*GetOutDev());
 294         Invalidate();
 295     }
 296 }
 297
 298 Size FixedText::getTextDimensions(Control const *pControl, const OUString &rTxt, tools::Long nMaxWidth)
 299 {
 300     DrawTextFlags nStyle = ImplGetTextStyle( pControl->GetStyle() );
 301     if ( !( pControl->GetStyle() & WB_NOLABEL ) )
 302         nStyle |= DrawTextFlags::Mnemonic;
 303
 304     return pControl->GetTextRect(tools::Rectangle( Point(), Size(nMaxWidth, 0x7fffffff)),
 305                                        rTxt, nStyle).GetSize();
 306 }
 307
 308 Size FixedText::CalcMinimumTextSize( Control const *pControl, tools::Long nMaxWidth )
 309 {
 310     Size aSize = getTextDimensions(pControl, pControl->GetText(), nMaxWidth);
 311
 312     if ( pControl->GetStyle() & WB_EXTRAOFFSET )
 313         aSize.AdjustWidth(2 );
 314
 315     // GetTextRect cannot take an empty string
 316     if ( aSize.Width() < 0 )
 317         aSize.setWidth( 0 );
 318     if ( aSize.Height() <= 0 )
 319         aSize.setHeight( pControl->GetTextHeight() );
 320
 321     return aSize;
 322 }
 323
 324 Size FixedText::CalcMinimumSize( tools::Long nMaxWidth ) const
 325 {
 326     return CalcWindowSize( CalcMinimumTextSize ( this, nMaxWidth ) );
 327 }
 328
 329 Size FixedText::GetOptimalSize() const
 330 {
 331     sal_Int32 nMaxAvailWidth = 0x7fffffff;
 332     if (m_nMaxWidthChars != -1)
 333     {
 334         OUStringBuffer aBuf(m_nMaxWidthChars);
 335         comphelper::string::padToLength(aBuf, m_nMaxWidthChars, 'x');
 336         nMaxAvailWidth = getTextDimensions(this,
 337             aBuf.makeStringAndClear(), 0x7fffffff).Width();
 338     }
 339     Size aRet = CalcMinimumSize(nMaxAvailWidth);
 340     if (m_nMinWidthChars != -1)
 341     {
 342         OUStringBuffer aBuf(m_nMinWidthChars);
 343         comphelper::string::padToLength(aBuf, m_nMinWidthChars, 'x');
 344         Size aMinAllowed = getTextDimensions(this,
 345             aBuf.makeStringAndClear(), 0x7fffffff);
 346         aRet.setWidth(std::max(aMinAllowed.Width(), aRet.Width()));
 347     }
 348     return aRet;
 349 }
 350
 351 void FixedText::FillLayoutData() const
 352 {
 353     mxLayoutData.emplace();
 354     ImplDraw(const_cast<FixedText*>(this)->GetOutDev(), SystemTextColorFlags::NONE, Point(), GetOutputSizePixel(), true);
 355     //const_cast<FixedText*>(this)->Invalidate();
 356 }
 357
 358 void FixedText::setMaxWidthChars(sal_Int32 nWidth)
 359 {
 360     if (nWidth != m_nMaxWidthChars)
 361     {
 362         m_nMaxWidthChars = nWidth;
 363         queue_resize();
 364     }
 365 }
 366
 367 void FixedText::setMinWidthChars(sal_Int32 nWidth)
 368 {
 369     if (nWidth != m_nMinWidthChars)
 370     {
 371         m_nMinWidthChars = nWidth;
 372         queue_resize();
 373     }
 374 }
 375
 376 bool FixedText::set_property(const OUString &rKey, const OUString &rValue)
 377 {
 378     if (rKey == "max-width-chars")
 379         setMaxWidthChars(rValue.toInt32());
 380     else if (rKey == "width-chars")
 381         setMinWidthChars(rValue.toInt32());
 382     else if (rKey == "ellipsize")
 383     {
 384         WinBits nBits = GetStyle();
 385         nBits &= ~WB_PATHELLIPSIS;
 386         if (rValue != "none")
 387         {
 388             SAL_WARN_IF(rValue != "end", "vcl.layout", "Only endellipsis support for now");
 389             nBits |= WB_PATHELLIPSIS;
 390         }
 391         SetStyle(nBits);
 392     }
 393     else
 394         return Control::set_property(rKey, rValue);
 395     return true;
 396 }
 397
 398 vcl::Window* FixedText::getAccessibleRelationLabelFor() const
 399 {
 400     vcl::Window *pWindow = Control::getAccessibleRelationLabelFor();
 401     if (pWindow)
 402         return pWindow;
 403     return get_mnemonic_widget();
 404 }
 405
 406 void FixedText::set_mnemonic_widget(vcl::Window *pWindow)
 407 {
 408     if (pWindow == m_pMnemonicWindow)
 409         return;
 410     if (m_pMnemonicWindow)
 411     {
 412         vcl::Window *pTempReEntryGuard = m_pMnemonicWindow;
 413         m_pMnemonicWindow = nullptr;
 414         pTempReEntryGuard->remove_mnemonic_label(this);
 415     }
 416     m_pMnemonicWindow = pWindow;
 417     if (m_pMnemonicWindow)
 418         m_pMnemonicWindow->add_mnemonic_label(this);
 419 }
 420
 421 FixedText::~FixedText()
 422 {
 423     disposeOnce();
 424 }
 425
 426 void FixedText::dispose()
 427 {
 428     set_mnemonic_widget(nullptr);
 429     m_pMnemonicWindow.clear();
 430     Control::dispose();
 431 }
 432
 433 SelectableFixedText::SelectableFixedText(vcl::Window* pParent, WinBits nStyle)
 434     : Edit(pParent, nStyle)
 435 {
 436     // no border
 437     SetBorderStyle( WindowBorderStyle::NOBORDER );
 438     // read-only
 439     SetReadOnly();
 440     // make it transparent
 441     SetPaintTransparent(true);
 442     SetControlBackground();
 443 }
 444
 445 void SelectableFixedText::ApplySettings(vcl::RenderContext& rRenderContext)
 446 {
 447     rRenderContext.SetBackground();
 448 }
 449
 450 void SelectableFixedText::LoseFocus()
 451 {
 452     Edit::LoseFocus();
 453     // clear cursor
 454     Invalidate();
 455 }
 456
 457 void SelectableFixedText::DumpAsPropertyTree(tools::JsonWriter& rJsonWriter)
 458 {
 459     Edit::DumpAsPropertyTree(rJsonWriter);
 460     rJsonWriter.put("type", "fixedtext");
 461     rJsonWriter.put("selectable", true);
 462 }
 463
 464 void FixedLine::ImplInit( vcl::Window* pParent, WinBits nStyle )
 465 {
 466     nStyle = ImplInitStyle( nStyle );
 467     Control::ImplInit( pParent, nStyle, nullptr );
 468     ApplySettings(*GetOutDev());
 469 }
 470
 471 WinBits FixedLine::ImplInitStyle( WinBits nStyle )
 472 {
 473     if ( !(nStyle & WB_NOGROUP) )
 474         nStyle |= WB_GROUP;
 475     return nStyle;
 476 }
 477
 478 const vcl::Font& FixedLine::GetCanonicalFont( const StyleSettings& _rStyle ) const
 479 {
 480     return _rStyle.GetGroupFont();
 481 }
 482
 483 const Color& FixedLine::GetCanonicalTextColor( const StyleSettings& _rStyle ) const
 484 {
 485     return _rStyle.GetGroupTextColor();
 486 }
 487
 488 void FixedLine::ImplDraw(vcl::RenderContext& rRenderContext)
 489 {
 490     // we need to measure according to the window, not according to the
 491     // RenderContext we paint to
 492     Size aOutSize = GetOutputSizePixel();
 493
 494     OUString aText = GetText();
 495     WinBits nWinStyle = GetStyle();
 496
 497     DecorationView aDecoView(&rRenderContext);
 498     if (aText.isEmpty())
 499     {
 500         if (nWinStyle & WB_VERT)
 501         {
 502             tools::Long nX = (aOutSize.Width() - 1) / 2;
 503             aDecoView.DrawSeparator(Point(nX, 0), Point(nX, aOutSize.Height() - 1));
 504         }
 505         else
 506         {
 507             tools::Long nY = (aOutSize.Height() - 1) / 2;
 508             aDecoView.DrawSeparator(Point(0, nY), Point(aOutSize.Width() - 1, nY), false);
 509         }
 510     }
 511     else if (nWinStyle & WB_VERT)
 512     {
 513         tools::Long nWidth = rRenderContext.GetTextWidth(aText);
 514         rRenderContext.Push(vcl::PushFlags::FONT);
 515         vcl::Font aFont(rRenderContext.GetFont());
 516         aFont.SetOrientation(900_deg10);
 517         SetFont(aFont);
 518         Point aStartPt(aOutSize.Width() / 2, aOutSize.Height() - 1);
 519         if (nWinStyle & WB_VCENTER)
 520             aStartPt.AdjustY( -((aOutSize.Height() - nWidth) / 2) );
 521         Point aTextPt(aStartPt);
 522         aTextPt.AdjustX( -(GetTextHeight() / 2) );
 523         rRenderContext.DrawText(aTextPt, aText, 0, aText.getLength());
 524         rRenderContext.Pop();
 525         if (aOutSize.Height() - aStartPt.Y() > FIXEDLINE_TEXT_BORDER)
 526             aDecoView.DrawSeparator(Point(aStartPt.X(), aStartPt.Y() + FIXEDLINE_TEXT_BORDER),
 527                                     Point(aStartPt.X(), aOutSize.Height() - 1));
 528         if (aStartPt.Y() - nWidth - FIXEDLINE_TEXT_BORDER > 0)
 529             aDecoView.DrawSeparator(Point(aStartPt.X(), 0),
 530                                     Point(aStartPt.X(), aStartPt.Y() - nWidth - FIXEDLINE_TEXT_BORDER));
 531     }
 532     else
 533     {
 534         DrawTextFlags nStyle = DrawTextFlags::Mnemonic | DrawTextFlags::Left | DrawTextFlags::VCenter | DrawTextFlags::EndEllipsis;
 535         tools::Rectangle aRect(0, 0, aOutSize.Width(), aOutSize.Height());
 536         const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
 537         if (nWinStyle & WB_CENTER)
 538             nStyle |= DrawTextFlags::Center;
 539
 540         if (!IsEnabled())
 541             nStyle |= DrawTextFlags::Disable;
 542         if (GetStyle() & WB_NOLABEL)
 543             nStyle &= ~DrawTextFlags::Mnemonic;
 544         if (rStyleSettings.GetOptions() & StyleSettingsOptions::Mono)
 545             nStyle |= DrawTextFlags::Mono;
 546
 547         aRect = DrawControlText(*GetOutDev(), aRect, aText, nStyle, nullptr, nullptr);
 548
 549         tools::Long nTop = aRect.Top() + ((aRect.GetHeight() - 1) / 2);
 550         aDecoView.DrawSeparator(Point(aRect.Right() + FIXEDLINE_TEXT_BORDER, nTop), Point(aOutSize.Width() - 1, nTop), false);
 551         if (aRect.Left() > FIXEDLINE_TEXT_BORDER)
 552             aDecoView.DrawSeparator(Point(0, nTop), Point(aRect.Left() - FIXEDLINE_TEXT_BORDER, nTop), false);
 553     }
 554 }
 555
 556 FixedLine::FixedLine( vcl::Window* pParent, WinBits nStyle ) :
 557     Control( WindowType::FIXEDLINE )
 558 {
 559     ImplInit( pParent, nStyle );
 560     SetSizePixel( Size( 2, 2 ) );
 561 }
 562
 563 void FixedLine::FillLayoutData() const
 564 {
 565     mxLayoutData.emplace();
 566     const_cast<FixedLine*>(this)->Invalidate();
 567 }
 568
 569 void FixedLine::ApplySettings(vcl::RenderContext& rRenderContext)
 570 {
 571     Control::ApplySettings(rRenderContext);
 572
 573     vcl::Window* pParent = GetParent();
 574     if (pParent->IsChildTransparentModeEnabled() && !IsControlBackground())
 575     {
 576         EnableChildTransparentMode();
 577         SetParentClipMode(ParentClipMode::NoClip);
 578         SetPaintTransparent(true);
 579         rRenderContext.SetBackground();
 580     }
 581     else
 582     {
 583         EnableChildTransparentMode(false);
 584         SetParentClipMode();
 585         SetPaintTransparent(false);
 586
 587         if (IsControlBackground())
 588             rRenderContext.SetBackground(GetControlBackground());
 589         else
 590             rRenderContext.SetBackground(pParent->GetBackground());
 591     }
 592 }
 593
 594 void FixedLine::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
 595 {
 596     ImplDraw(rRenderContext);
 597 }
 598
 599 void FixedLine::Draw( OutputDevice*, const Point&, SystemTextColorFlags )
 600 {
 601 }
 602
 603 void FixedLine::Resize()
 604 {
 605     Control::Resize();
 606     Invalidate();
 607 }
 608
 609 void FixedLine::StateChanged( StateChangedType nType )
 610 {
 611     Control::StateChanged( nType );
 612
 613     if ( (nType == StateChangedType::Enable) ||
 614          (nType == StateChangedType::Text) ||
 615          (nType == StateChangedType::UpdateMode) )
 616     {
 617         if ( IsReallyVisible() && IsUpdateMode() )
 618             Invalidate();
 619     }
 620     else if ( nType == StateChangedType::Style )
 621     {
 622         SetStyle( ImplInitStyle( GetStyle() ) );
 623         if ( (GetPrevStyle() & FIXEDLINE_VIEW_STYLE) !=
 624              (GetStyle() & FIXEDLINE_VIEW_STYLE) )
 625             Invalidate();
 626     }
 627     else if ( (nType == StateChangedType::Zoom)  ||
 628               (nType == StateChangedType::Style) ||
 629               (nType == StateChangedType::ControlFont) )
 630     {
 631         ApplySettings(*GetOutDev());
 632         Invalidate();
 633     }
 634     else if ( nType == StateChangedType::ControlForeground )
 635     {
 636         ApplySettings(*GetOutDev());
 637         Invalidate();
 638     }
 639     else if ( nType == StateChangedType::ControlBackground )
 640     {
 641         ApplySettings(*GetOutDev());
 642         Invalidate();
 643     }
 644 }
 645
 646 void FixedLine::DataChanged( const DataChangedEvent& rDCEvt )
 647 {
 648     Control::DataChanged( rDCEvt );
 649
 650     if ( (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
 651          (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
 652          ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
 653           (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
 654     {
 655         ApplySettings(*GetOutDev());
 656         Invalidate();
 657     }
 658 }
 659
 660 Size FixedLine::GetOptimalSize() const
 661 {
 662     return CalcWindowSize( FixedText::CalcMinimumTextSize ( this ) );
 663 }
 664
 665 void FixedLine::DumpAsPropertyTree(tools::JsonWriter& rJsonWriter)
 666 {
 667     Control::DumpAsPropertyTree(rJsonWriter);
 668     rJsonWriter.put("type", "separator");
 669     rJsonWriter.put("orientation", (GetStyle() & WB_VERT) ? "vertical" : "horizontal");
 670 }
 671
 672 void FixedBitmap::ImplInit( vcl::Window* pParent, WinBits nStyle )
 673 {
 674     nStyle = ImplInitStyle( nStyle );
 675     Control::ImplInit( pParent, nStyle, nullptr );
 676     ApplySettings(*GetOutDev());
 677 }
 678
 679 WinBits FixedBitmap::ImplInitStyle( WinBits nStyle )
 680 {
 681     if ( !(nStyle & WB_NOGROUP) )
 682         nStyle |= WB_GROUP;
 683     return nStyle;
 684 }
 685
 686 FixedBitmap::FixedBitmap( vcl::Window* pParent, WinBits nStyle ) :
 687     Control( WindowType::FIXEDBITMAP )
 688 {
 689     ImplInit( pParent, nStyle );
 690 }
 691
 692 void FixedBitmap::ImplDraw( OutputDevice* pDev, const Point& rPos, const Size& rSize )
 693 {
 694     // do we have a Bitmap?
 695     if ( !maBitmap.IsEmpty() )
 696     {
 697         if ( GetStyle() & WB_SCALE )
 698             pDev->DrawBitmapEx( rPos, rSize, maBitmap );
 699         else
 700         {
 701             Point aPos = ImplCalcPos( GetStyle(), rPos, maBitmap.GetSizePixel(), rSize );
 702             pDev->DrawBitmapEx( aPos, maBitmap );
 703         }
 704     }
 705 }
 706
 707 void FixedBitmap::ApplySettings(vcl::RenderContext& rRenderContext)
 708 {
 709     vcl::Window* pParent = GetParent();
 710     if (pParent->IsChildTransparentModeEnabled() && !IsControlBackground())
 711     {
 712         EnableChildTransparentMode();
 713         SetParentClipMode(ParentClipMode::NoClip);
 714         SetPaintTransparent(true);
 715         rRenderContext.SetBackground();
 716     }
 717     else
 718     {
 719         EnableChildTransparentMode(false);
 720         SetParentClipMode();
 721         SetPaintTransparent(false);
 722
 723         if (IsControlBackground())
 724             rRenderContext.SetBackground(GetControlBackground());
 725         else
 726             rRenderContext.SetBackground(pParent->GetBackground());
 727     }
 728 }
 729
 730 void FixedBitmap::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
 731 {
 732     ImplDraw(&rRenderContext, Point(), GetOutputSizePixel());
 733 }
 734
 735 void FixedBitmap::Draw( OutputDevice* pDev, const Point& rPos,
 736                         SystemTextColorFlags )
 737 {
 738     Point       aPos  = pDev->LogicToPixel( rPos );
 739     Size        aSize = GetSizePixel();
 740     tools::Rectangle   aRect( aPos, aSize );
 741
 742     pDev->Push();
 743     pDev->SetMapMode();
 744
 745     // Border
 746     if ( GetStyle() & WB_BORDER )
 747     {
 748         DecorationView aDecoView( pDev );
 749         aRect = aDecoView.DrawFrame( aRect, DrawFrameStyle::DoubleIn );
 750     }
 751     pDev->IntersectClipRegion( aRect );
 752     ImplDraw( pDev, aRect.TopLeft(), aRect.GetSize() );
 753
 754     pDev->Pop();
 755 }
 756
 757 void FixedBitmap::Resize()
 758 {
 759     Control::Resize();
 760     Invalidate();
 761 }
 762
 763 void FixedBitmap::StateChanged( StateChangedType nType )
 764 {
 765     Control::StateChanged( nType );
 766
 767     if ( (nType == StateChangedType::Data) ||
 768          (nType == StateChangedType::UpdateMode) )
 769     {
 770         if ( IsReallyVisible() && IsUpdateMode() )
 771             Invalidate();
 772     }
 773     else if ( nType == StateChangedType::Style )
 774     {
 775         SetStyle( ImplInitStyle( GetStyle() ) );
 776         if ( (GetPrevStyle() & FIXEDBITMAP_VIEW_STYLE) !=
 777              (GetStyle() & FIXEDBITMAP_VIEW_STYLE) )
 778             Invalidate();
 779     }
 780     else if ( nType == StateChangedType::ControlBackground )
 781     {
 782         ApplySettings(*GetOutDev());
 783         Invalidate();
 784     }
 785 }
 786
 787 void FixedBitmap::DataChanged( const DataChangedEvent& rDCEvt )
 788 {
 789     Control::DataChanged( rDCEvt );
 790
 791     if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
 792          (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
 793     {
 794         ApplySettings(*GetOutDev());
 795         Invalidate();
 796     }
 797 }
 798
 799 void FixedBitmap::SetBitmap( const BitmapEx& rBitmap )
 800 {
 801     maBitmap = rBitmap;
 802     CompatStateChanged( StateChangedType::Data );
 803     queue_resize();
 804 }
 805
 806 void FixedImage::ImplInit( vcl::Window* pParent, WinBits nStyle )
 807 {
 808     nStyle = ImplInitStyle( nStyle );
 809     Control::ImplInit( pParent, nStyle, nullptr );
 810     ApplySettings(*GetOutDev());
 811 }
 812
 813 WinBits FixedImage::ImplInitStyle( WinBits nStyle )
 814 {
 815     if ( !(nStyle & WB_NOGROUP) )
 816         nStyle |= WB_GROUP;
 817     return nStyle;
 818 }
 819
 820 FixedImage::FixedImage( vcl::Window* pParent, WinBits nStyle ) :
 821     Control( WindowType::FIXEDIMAGE )
 822 {
 823     ImplInit( pParent, nStyle );
 824 }
 825
 826 void FixedImage::ImplDraw( OutputDevice* pDev,
 827                            const Point& rPos, const Size& rSize )
 828 {
 829     DrawImageFlags nStyle = DrawImageFlags::NONE;
 830     if ( !IsEnabled() )
 831         nStyle |= DrawImageFlags::Disable;
 832
 833     Image *pImage = &maImage;
 834
 835     // do we have an image?
 836     if ( !(!(*pImage)) )
 837     {
 838         if ( GetStyle() & WB_SCALE )
 839             pDev->DrawImage( rPos, rSize, *pImage, nStyle );
 840         else
 841         {
 842             Point aPos = ImplCalcPos( GetStyle(), rPos, pImage->GetSizePixel(), rSize );
 843             pDev->DrawImage( aPos, *pImage, nStyle );
 844         }
 845     }
 846 }
 847
 848 void FixedImage::ApplySettings(vcl::RenderContext& rRenderContext)
 849 {
 850     vcl::Window* pParent = GetParent();
 851     if (pParent && pParent->IsChildTransparentModeEnabled() && !IsControlBackground())
 852     {
 853         EnableChildTransparentMode();
 854         SetParentClipMode(ParentClipMode::NoClip);
 855         SetPaintTransparent(true);
 856         rRenderContext.SetBackground();
 857     }
 858     else
 859     {
 860         EnableChildTransparentMode(false);
 861         SetParentClipMode();
 862         SetPaintTransparent(false);
 863
 864         if (IsControlBackground())
 865             rRenderContext.SetBackground(GetControlBackground());
 866         else if (pParent)
 867             rRenderContext.SetBackground(pParent->GetBackground());
 868     }
 869 }
 870
 871
 872 void FixedImage::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
 873 {
 874     ImplDraw(&rRenderContext, Point(), GetOutputSizePixel());
 875 }
 876
 877 Size FixedImage::GetOptimalSize() const
 878 {
 879     return maImage.GetSizePixel();
 880 }
 881
 882 void FixedImage::Draw( OutputDevice* pDev, const Point& rPos,
 883                        SystemTextColorFlags )
 884 {
 885     Point       aPos  = pDev->LogicToPixel( rPos );
 886     Size        aSize = GetSizePixel();
 887     tools::Rectangle   aRect( aPos, aSize );
 888
 889     pDev->Push();
 890     pDev->SetMapMode();
 891
 892     // Border
 893     if ( GetStyle() & WB_BORDER )
 894     {
 895         ImplDrawFrame( pDev, aRect );
 896     }
 897     pDev->IntersectClipRegion( aRect );
 898     ImplDraw( pDev, aRect.TopLeft(), aRect.GetSize() );
 899
 900     pDev->Pop();
 901 }
 902
 903 void FixedImage::Resize()
 904 {
 905     Control::Resize();
 906     Invalidate();
 907 }
 908
 909 void FixedImage::StateChanged( StateChangedType nType )
 910 {
 911     Control::StateChanged( nType );
 912
 913     if ( (nType == StateChangedType::Enable) ||
 914          (nType == StateChangedType::Data) ||
 915          (nType == StateChangedType::UpdateMode) )
 916     {
 917         if ( IsReallyVisible() && IsUpdateMode() )
 918             Invalidate();
 919     }
 920     else if ( nType == StateChangedType::Style )
 921     {
 922         SetStyle( ImplInitStyle( GetStyle() ) );
 923         if ( (GetPrevStyle() & FIXEDIMAGE_VIEW_STYLE) !=
 924              (GetStyle() & FIXEDIMAGE_VIEW_STYLE) )
 925             Invalidate();
 926     }
 927     else if ( nType == StateChangedType::ControlBackground )
 928     {
 929         ApplySettings(*GetOutDev());
 930         Invalidate();
 931     }
 932 }
 933
 934 void FixedImage::DataChanged( const DataChangedEvent& rDCEvt )
 935 {
 936     Control::DataChanged( rDCEvt );
 937
 938     if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
 939          (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
 940     {
 941         ApplySettings(*GetOutDev());
 942         Invalidate();
 943     }
 944 }
 945
 946 void FixedImage::SetImage( const Image& rImage )
 947 {
 948     if ( rImage != maImage )
 949     {
 950         maImage = rImage;
 951         CompatStateChanged( StateChangedType::Data );
 952         queue_resize();
 953     }
 954 }
 955
 956 bool FixedImage::set_property(const OUString &rKey, const OUString &rValue)
 957 {
 958     if (rKey == "icon-size")
 959     {
 960         WinBits nBits = GetStyle();
 961         nBits &= ~WB_SMALLSTYLE;
 962         if (rValue == "2")
 963             nBits |= WB_SMALLSTYLE;
 964         SetStyle(nBits);
 965     }
 966     else
 967         return Control::set_property(rKey, rValue);
 968     return true;
 969 }
 970
 971 void FixedImage::DumpAsPropertyTree(tools::JsonWriter& rJsonWriter)
 972 {
 973     Control::DumpAsPropertyTree(rJsonWriter);
 974     rJsonWriter.put("id", get_id());
 975     rJsonWriter.put("type", "image");
 976     if (!!maImage)
 977     {
 978         SvMemoryStream aOStm(6535, 6535);
 979         if(GraphicConverter::Export(aOStm, maImage.GetBitmapEx(), ConvertDataFormat::PNG) == ERRCODE_NONE)
 980         {
 981             css::uno::Sequence<sal_Int8> aSeq( static_cast<sal_Int8 const *>(aOStm.GetData()), aOStm.Tell());
 982             OStringBuffer aBuffer("data:image/png;base64,");
 983             ::comphelper::Base64::encode(aBuffer, aSeq);
 984             rJsonWriter.put("image", aBuffer);
 985         }
 986     }
 987 }
 988
 989
 990 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */