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
  21 #include "tools/rc.h"
  22
  23 #include "vcl/decoview.hxx"
  24 #include "vcl/dialog.hxx"
  25 #include "vcl/event.hxx"
  26 #include "vcl/fixed.hxx"
  27 #include "vcl/svapp.hxx"
  28 #include <comphelper/string.hxx>
  29 #include "controldata.hxx"
  30 #include "impimagetree.hxx"
  31 #include "window.h"
  32
  33 // =======================================================================
  34
  35 #define FIXEDLINE_TEXT_BORDER    4
  36
  37 #define FIXEDTEXT_VIEW_STYLE    (WB_3DLOOK |                        \
  38                                  WB_LEFT | WB_CENTER | WB_RIGHT |   \
  39                                  WB_TOP | WB_VCENTER | WB_BOTTOM |  \
  40                                  WB_WORDBREAK | WB_NOLABEL |        \
  41                                  WB_INFO | WB_PATHELLIPSIS)
  42 #define FIXEDLINE_VIEW_STYLE    (WB_3DLOOK | WB_NOLABEL)
  43 #define FIXEDBITMAP_VIEW_STYLE  (WB_3DLOOK |                        \
  44                                  WB_LEFT | WB_CENTER | WB_RIGHT |   \
  45                                  WB_TOP | WB_VCENTER | WB_BOTTOM |  \
  46                                  WB_SCALE)
  47 #define FIXEDIMAGE_VIEW_STYLE   (WB_3DLOOK |                        \
  48                                  WB_LEFT | WB_CENTER | WB_RIGHT |   \
  49                                  WB_TOP | WB_VCENTER | WB_BOTTOM |  \
  50                                  WB_SCALE)
  51
  52 // =======================================================================
  53
  54 static Point ImplCalcPos( WinBits nStyle, const Point& rPos,
  55                           const Size& rObjSize, const Size& rWinSize )
  56 {
  57     long    nX;
  58     long    nY;
  59
  60     if ( nStyle & WB_LEFT )
  61         nX = 0;
  62     else if ( nStyle & WB_RIGHT )
  63         nX = rWinSize.Width()-rObjSize.Width();
  64     else
  65         nX = (rWinSize.Width()-rObjSize.Width())/2;
  66
  67     if ( nStyle & WB_TOP )
  68         nY = 0;
  69     else if ( nStyle & WB_BOTTOM )
  70         nY = rWinSize.Height()-rObjSize.Height();
  71     else
  72         nY = (rWinSize.Height()-rObjSize.Height())/2;
  73
  74     if ( nStyle & WB_TOPLEFTVISIBLE )
  75     {
  76         if ( nX < 0 )
  77             nX = 0;
  78         if ( nY < 0 )
  79             nY = 0;
  80     }
  81
  82     Point aPos( nX+rPos.X(), nY+rPos.Y() );
  83     return aPos;
  84 }
  85
  86 // =======================================================================
  87
  88 void FixedText::ImplInit( Window* pParent, WinBits nStyle )
  89 {
  90     nStyle = ImplInitStyle( nStyle );
  91     Control::ImplInit( pParent, nStyle, NULL );
  92     ImplInitSettings( sal_True, sal_True, sal_True );
  93 }
  94
  95 // -----------------------------------------------------------------------
  96
  97 WinBits FixedText::ImplInitStyle( WinBits nStyle )
  98 {
  99     if ( !(nStyle & WB_NOGROUP) )
 100         nStyle |= WB_GROUP;
 101     return nStyle;
 102 }
 103
 104 // -----------------------------------------------------------------
 105
 106 const Font& FixedText::GetCanonicalFont( const StyleSettings& _rStyle ) const
 107 {
 108     return ( GetStyle() & WB_INFO ) ? _rStyle.GetInfoFont() : _rStyle.GetLabelFont();
 109 }
 110
 111 // -----------------------------------------------------------------
 112 const Color& FixedText::GetCanonicalTextColor( const StyleSettings& _rStyle ) const
 113 {
 114     return ( GetStyle() & WB_INFO ) ? _rStyle.GetInfoTextColor() : _rStyle.GetLabelTextColor();
 115 }
 116
 117 // -----------------------------------------------------------------------
 118
 119 void FixedText::ImplInitSettings( sal_Bool bFont,
 120                                   sal_Bool bForeground, sal_Bool bBackground )
 121 {
 122     Control::ImplInitSettings( bFont, bForeground );
 123
 124     if ( bBackground )
 125     {
 126         Window* pParent = GetParent();
 127         if ( pParent->IsChildTransparentModeEnabled() && !IsControlBackground() )
 128         {
 129             EnableChildTransparentMode( sal_True );
 130             SetParentClipMode( PARENTCLIPMODE_NOCLIP );
 131             SetPaintTransparent( sal_True );
 132             SetBackground();
 133         }
 134         else
 135         {
 136             EnableChildTransparentMode( sal_False );
 137             SetParentClipMode( 0 );
 138             SetPaintTransparent( sal_False );
 139
 140             if ( IsControlBackground() )
 141                 SetBackground( GetControlBackground() );
 142             else
 143                 SetBackground( pParent->GetBackground() );
 144         }
 145     }
 146 }
 147
 148 // -----------------------------------------------------------------------
 149
 150 FixedText::FixedText( Window* pParent, WinBits nStyle )
 151     : Control(WINDOW_FIXEDTEXT)
 152     , m_nMaxWidthChars(-1)
 153     , m_nMinWidthChars(-1)
 154     , m_pMnemonicWindow(NULL)
 155 {
 156     ImplInit( pParent, nStyle );
 157 }
 158
 159 // -----------------------------------------------------------------------
 160
 161 FixedText::FixedText( Window* pParent, const ResId& rResId )
 162     : Control(WINDOW_FIXEDTEXT)
 163     , m_nMaxWidthChars(-1)
 164     , m_nMinWidthChars(-1)
 165     , m_pMnemonicWindow(NULL)
 166 {
 167     rResId.SetRT( RSC_TEXT );
 168     WinBits nStyle = ImplInitRes( rResId );
 169     ImplInit( pParent, nStyle );
 170     ImplLoadRes( rResId );
 171
 172     if ( !(nStyle & WB_HIDE) )
 173         Show();
 174 }
 175
 176 // -----------------------------------------------------------------------
 177
 178 sal_uInt16 FixedText::ImplGetTextStyle( WinBits nWinStyle )
 179 {
 180     sal_uInt16 nTextStyle = TEXT_DRAW_MNEMONIC | TEXT_DRAW_ENDELLIPSIS;
 181
 182     if( ! (nWinStyle & WB_NOMULTILINE) )
 183         nTextStyle |= TEXT_DRAW_MULTILINE;
 184
 185     if ( nWinStyle & WB_RIGHT )
 186         nTextStyle |= TEXT_DRAW_RIGHT;
 187     else if ( nWinStyle & WB_CENTER )
 188         nTextStyle |= TEXT_DRAW_CENTER;
 189     else
 190         nTextStyle |= TEXT_DRAW_LEFT;
 191     if ( nWinStyle & WB_BOTTOM )
 192         nTextStyle |= TEXT_DRAW_BOTTOM;
 193     else if ( nWinStyle & WB_VCENTER )
 194         nTextStyle |= TEXT_DRAW_VCENTER;
 195     else
 196         nTextStyle |= TEXT_DRAW_TOP;
 197     if ( nWinStyle & WB_WORDBREAK )
 198     {
 199         nTextStyle |= TEXT_DRAW_WORDBREAK;
 200         if ( (nWinStyle & WB_HYPHENATION ) == WB_HYPHENATION )
 201             nTextStyle |= TEXT_DRAW_WORDBREAK_HYPHENATION;
 202     }
 203     if ( nWinStyle & WB_NOLABEL )
 204         nTextStyle &= ~TEXT_DRAW_MNEMONIC;
 205
 206     return nTextStyle;
 207 }
 208
 209 // -----------------------------------------------------------------------
 210
 211 void FixedText::ImplDraw( OutputDevice* pDev, sal_uLong nDrawFlags,
 212                           const Point& rPos, const Size& rSize,
 213                           bool bFillLayout
 214                           ) const
 215 {
 216     const StyleSettings&    rStyleSettings = GetSettings().GetStyleSettings();
 217     WinBits                 nWinStyle = GetStyle();
 218     OUString           aText( GetText() );
 219     sal_uInt16              nTextStyle = FixedText::ImplGetTextStyle( nWinStyle );
 220     Point                   aPos = rPos;
 221
 222     if ( nWinStyle & WB_EXTRAOFFSET )
 223         aPos.X() += 2;
 224
 225     if ( nWinStyle & WB_PATHELLIPSIS )
 226     {
 227         nTextStyle &= ~(TEXT_DRAW_ENDELLIPSIS | TEXT_DRAW_MULTILINE | TEXT_DRAW_WORDBREAK);
 228         nTextStyle |= TEXT_DRAW_PATHELLIPSIS;
 229     }
 230     if ( nDrawFlags & WINDOW_DRAW_NOMNEMONIC )
 231     {
 232         if ( nTextStyle & TEXT_DRAW_MNEMONIC )
 233         {
 234             aText = GetNonMnemonicString( aText );
 235             nTextStyle &= ~TEXT_DRAW_MNEMONIC;
 236         }
 237     }
 238     if ( !(nDrawFlags & WINDOW_DRAW_NODISABLE) )
 239     {
 240         if ( !IsEnabled() )
 241             nTextStyle |= TEXT_DRAW_DISABLE;
 242     }
 243     if ( (nDrawFlags & WINDOW_DRAW_MONO) ||
 244          (rStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
 245         nTextStyle |= TEXT_DRAW_MONO;
 246
 247     if( bFillLayout )
 248         mpControlData->mpLayoutData->m_aDisplayText = OUString();
 249
 250     Rectangle aRect( Rectangle( aPos, rSize ) );
 251     DrawControlText( *pDev, aRect, aText, nTextStyle,
 252         bFillLayout ? &mpControlData->mpLayoutData->m_aUnicodeBoundRects : NULL,
 253         bFillLayout ? &mpControlData->mpLayoutData->m_aDisplayText : NULL
 254     );
 255 }
 256
 257 // -----------------------------------------------------------------------
 258
 259 void FixedText::Paint( const Rectangle& )
 260 {
 261     ImplDraw( this, 0, Point(), GetOutputSizePixel() );
 262 }
 263
 264 // -----------------------------------------------------------------------
 265
 266 void FixedText::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
 267                       sal_uLong nFlags )
 268 {
 269     ImplInitSettings( sal_True, sal_True, sal_True );
 270
 271     Point       aPos  = pDev->LogicToPixel( rPos );
 272     Size        aSize = pDev->LogicToPixel( rSize );
 273     Font        aFont = GetDrawPixelFont( pDev );
 274
 275     pDev->Push();
 276     pDev->SetMapMode();
 277     pDev->SetFont( aFont );
 278     if ( nFlags & WINDOW_DRAW_MONO )
 279         pDev->SetTextColor( Color( COL_BLACK ) );
 280     else
 281         pDev->SetTextColor( GetTextColor() );
 282     pDev->SetTextFillColor();
 283
 284     bool bBorder = !(nFlags & WINDOW_DRAW_NOBORDER ) && (GetStyle() & WB_BORDER);
 285     bool bBackground = !(nFlags & WINDOW_DRAW_NOBACKGROUND) && IsControlBackground();
 286     if ( bBorder || bBackground )
 287     {
 288         Rectangle aRect( aPos, aSize );
 289         if ( bBorder )
 290         {
 291             ImplDrawFrame( pDev, aRect );
 292         }
 293         if ( bBackground )
 294         {
 295             pDev->SetFillColor( GetControlBackground() );
 296             pDev->DrawRect( aRect );
 297         }
 298     }
 299
 300     ImplDraw( pDev, nFlags, aPos, aSize );
 301     pDev->Pop();
 302 }
 303
 304 // -----------------------------------------------------------------------
 305
 306 void FixedText::Resize()
 307 {
 308     Control::Resize();
 309     Invalidate();
 310 }
 311
 312 // -----------------------------------------------------------------------
 313
 314 void FixedText::StateChanged( StateChangedType nType )
 315 {
 316     Control::StateChanged( nType );
 317
 318     if ( (nType == STATE_CHANGE_ENABLE) ||
 319          (nType == STATE_CHANGE_TEXT) ||
 320          (nType == STATE_CHANGE_UPDATEMODE) )
 321     {
 322         if ( IsReallyVisible() && IsUpdateMode() )
 323             Invalidate();
 324     }
 325     else if ( nType == STATE_CHANGE_STYLE )
 326     {
 327         SetStyle( ImplInitStyle( GetStyle() ) );
 328         if ( (GetPrevStyle() & FIXEDTEXT_VIEW_STYLE) !=
 329              (GetStyle() & FIXEDTEXT_VIEW_STYLE) )
 330         {
 331             ImplInitSettings( sal_True, sal_False, sal_False );
 332             Invalidate();
 333         }
 334     }
 335     else if ( (nType == STATE_CHANGE_ZOOM)  ||
 336               (nType == STATE_CHANGE_CONTROLFONT) )
 337     {
 338         ImplInitSettings( sal_True, sal_False, sal_False );
 339         Invalidate();
 340     }
 341     else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
 342     {
 343         ImplInitSettings( sal_False, sal_True, sal_False );
 344         Invalidate();
 345     }
 346     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 347     {
 348         ImplInitSettings( sal_False, sal_False, sal_True );
 349         Invalidate();
 350     }
 351 }
 352
 353 // -----------------------------------------------------------------------
 354
 355 void FixedText::DataChanged( const DataChangedEvent& rDCEvt )
 356 {
 357     Control::DataChanged( rDCEvt );
 358
 359     if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
 360          (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
 361          ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 362           (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
 363     {
 364         ImplInitSettings( sal_True, sal_True, sal_True );
 365         Invalidate();
 366     }
 367 }
 368
 369 // -----------------------------------------------------------------------
 370
 371 Size FixedText::getTextDimensions(Control const *pControl, const OUString &rTxt, long nMaxWidth)
 372 {
 373     sal_uInt16 nStyle = ImplGetTextStyle( pControl->GetStyle() );
 374     if ( !( pControl->GetStyle() & WB_NOLABEL ) )
 375         nStyle |= TEXT_DRAW_MNEMONIC;
 376
 377     return pControl->GetTextRect(Rectangle( Point(), Size(nMaxWidth, 0x7fffffff)),
 378                                        rTxt, nStyle).GetSize();
 379 }
 380
 381
 382 Size FixedText::CalcMinimumTextSize( Control const *pControl, long nMaxWidth )
 383 {
 384     Size aSize = getTextDimensions(pControl, pControl->GetText(), nMaxWidth);
 385
 386     if ( pControl->GetStyle() & WB_EXTRAOFFSET )
 387         aSize.Width() += 2;
 388
 389     // GetTextRect cannot take an empty string
 390     if ( aSize.Width() < 0 )
 391         aSize.Width() = 0;
 392     if ( aSize.Height() <= 0 )
 393         aSize.Height() = pControl->GetTextHeight();
 394
 395     return aSize;
 396 }
 397
 398 Size FixedText::CalcMinimumSize( long nMaxWidth ) const
 399 {
 400     return CalcWindowSize( CalcMinimumTextSize ( this, nMaxWidth ) );
 401 }
 402 // -----------------------------------------------------------------------
 403
 404 Size FixedText::GetOptimalSize() const
 405 {
 406     sal_Int32 nMaxAvailWidth = 0x7fffffff;
 407     const OUString &rTxt = GetText();
 408     if (m_nMaxWidthChars != -1 && m_nMaxWidthChars < rTxt.getLength())
 409     {
 410         nMaxAvailWidth = getTextDimensions(this,
 411             rTxt.copy(0, m_nMaxWidthChars), 0x7fffffff).Width();
 412     }
 413     Size aRet = CalcMinimumSize(nMaxAvailWidth);
 414     if (m_nMinWidthChars != -1)
 415     {
 416         OUStringBuffer aBuf;
 417         comphelper::string::padToLength(aBuf, m_nMinWidthChars, 'x');
 418         Size aMinAllowed = getTextDimensions(this,
 419             aBuf.makeStringAndClear(), 0x7fffffff);
 420         if (aMinAllowed.Width() > aRet.Width())
 421             aRet = aMinAllowed;
 422     }
 423     return aRet;
 424 }
 425
 426 // -----------------------------------------------------------------------
 427
 428 void FixedText::FillLayoutData() const
 429 {
 430     mpControlData->mpLayoutData = new vcl::ControlLayoutData();
 431     ImplDraw( const_cast<FixedText*>(this), 0, Point(), GetOutputSizePixel(), true );
 432 }
 433
 434 void FixedText::setMaxWidthChars(sal_Int32 nWidth)
 435 {
 436     if (nWidth != m_nMaxWidthChars)
 437     {
 438         m_nMaxWidthChars = nWidth;
 439         queue_resize();
 440     }
 441 }
 442
 443 void FixedText::setMinWidthChars(sal_Int32 nWidth)
 444 {
 445     if (nWidth != m_nMinWidthChars)
 446     {
 447         m_nMinWidthChars = nWidth;
 448         queue_resize();
 449     }
 450 }
 451
 452 bool FixedText::set_property(const OString &rKey, const OString &rValue)
 453 {
 454     if (rKey == "max-width-chars")
 455         setMaxWidthChars(rValue.toInt32());
 456     else if (rKey == "width-chars")
 457         setMinWidthChars(rValue.toInt32());
 458     else
 459         return Control::set_property(rKey, rValue);
 460     return true;
 461 }
 462
 463 Window* FixedText::getAccessibleRelationLabelFor() const
 464 {
 465     Window *pWindow = Control::getAccessibleRelationLabelFor();
 466     if (pWindow)
 467         return pWindow;
 468     return get_mnemonic_widget();
 469 }
 470
 471 void FixedText::set_mnemonic_widget(Window *pWindow)
 472 {
 473     if (pWindow == m_pMnemonicWindow)
 474         return;
 475     if (m_pMnemonicWindow)
 476     {
 477         Window *pTempReEntryGuard = m_pMnemonicWindow;
 478         m_pMnemonicWindow = NULL;
 479         pTempReEntryGuard->remove_mnemonic_label(this);
 480     }
 481     m_pMnemonicWindow = pWindow;
 482     if (m_pMnemonicWindow)
 483         m_pMnemonicWindow->add_mnemonic_label(this);
 484 }
 485
 486 FixedText::~FixedText()
 487 {
 488     set_mnemonic_widget(NULL);
 489 }
 490
 491 SelectableFixedText::SelectableFixedText(Window* pParent, WinBits nStyle)
 492     : Edit(pParent, nStyle)
 493 {
 494     // no border
 495     SetBorderStyle( WINDOW_BORDER_NOBORDER );
 496     // read-only
 497     SetReadOnly();
 498     // make it transparent
 499     SetControlBackground();
 500     SetBackground();
 501     SetPaintTransparent( sal_True );
 502 }
 503
 504 // -----------------------------------------------------------------------
 505
 506 void SelectableFixedText::LoseFocus()
 507 {
 508     Edit::LoseFocus();
 509     // clear cursor
 510     Invalidate();
 511 }
 512
 513 // =======================================================================
 514
 515 void FixedLine::ImplInit( Window* pParent, WinBits nStyle )
 516 {
 517     nStyle = ImplInitStyle( nStyle );
 518     Control::ImplInit( pParent, nStyle, NULL );
 519     ImplInitSettings( sal_True, sal_True, sal_True );
 520 }
 521
 522 // -----------------------------------------------------------------------
 523
 524 WinBits FixedLine::ImplInitStyle( WinBits nStyle )
 525 {
 526     if ( !(nStyle & WB_NOGROUP) )
 527         nStyle |= WB_GROUP;
 528     return nStyle;
 529 }
 530
 531 // -----------------------------------------------------------------
 532
 533 const Font& FixedLine::GetCanonicalFont( const StyleSettings& _rStyle ) const
 534 {
 535     return _rStyle.GetGroupFont();
 536 }
 537
 538 // -----------------------------------------------------------------
 539 const Color& FixedLine::GetCanonicalTextColor( const StyleSettings& _rStyle ) const
 540 {
 541     return _rStyle.GetGroupTextColor();
 542 }
 543
 544 // -----------------------------------------------------------------------
 545
 546 void FixedLine::ImplInitSettings( sal_Bool bFont,
 547                                   sal_Bool bForeground, sal_Bool bBackground )
 548 {
 549     Control::ImplInitSettings( bFont, bForeground );
 550
 551     if ( bBackground )
 552     {
 553         Window* pParent = GetParent();
 554         if ( pParent->IsChildTransparentModeEnabled() && !IsControlBackground() )
 555         {
 556             EnableChildTransparentMode( sal_True );
 557             SetParentClipMode( PARENTCLIPMODE_NOCLIP );
 558             SetPaintTransparent( sal_True );
 559             SetBackground();
 560         }
 561         else
 562         {
 563             EnableChildTransparentMode( sal_False );
 564             SetParentClipMode( 0 );
 565             SetPaintTransparent( sal_False );
 566
 567             if ( IsControlBackground() )
 568                 SetBackground( GetControlBackground() );
 569             else
 570                 SetBackground( pParent->GetBackground() );
 571         }
 572     }
 573 }
 574
 575 // -----------------------------------------------------------------------
 576
 577 void FixedLine::ImplDraw( bool bLayout )
 578 {
 579     Size                    aOutSize = GetOutputSizePixel();
 580     String                  aText = GetText();
 581     WinBits                 nWinStyle = GetStyle();
 582     MetricVector*           pVector = bLayout ? &mpControlData->mpLayoutData->m_aUnicodeBoundRects : NULL;
 583     OUString*               pDisplayText = bLayout ? &mpControlData->mpLayoutData->m_aDisplayText : NULL;
 584
 585     DecorationView aDecoView( this );
 586     if ( !aText.Len() )
 587     {
 588         if( !pVector )
 589         {
 590             if ( nWinStyle & WB_VERT )
 591             {
 592                 long nX = (aOutSize.Width()-1)/2;
 593                 aDecoView.DrawSeparator( Point( nX, 0 ), Point( nX, aOutSize.Height()-1 ) );
 594             }
 595             else
 596             {
 597                 long nY = (aOutSize.Height()-1)/2;
 598                 aDecoView.DrawSeparator( Point( 0, nY ), Point( aOutSize.Width()-1, nY ), false );
 599             }
 600         }
 601     }
 602     else if( (nWinStyle & WB_VERT) )
 603     {
 604         long nWidth = GetTextWidth( aText );
 605         Push( PUSH_FONT );
 606         Font aFont( GetFont() );
 607         aFont.SetOrientation( 900 );
 608         SetFont( aFont );
 609         Point aStartPt( aOutSize.Width()/2, aOutSize.Height()-1 );
 610         if( (nWinStyle & WB_VCENTER) )
 611             aStartPt.Y() -= (aOutSize.Height() - nWidth)/2;
 612         Point aTextPt( aStartPt );
 613         aTextPt.X() -= GetTextHeight()/2;
 614         DrawText( aTextPt, aText, 0, STRING_LEN, pVector, pDisplayText );
 615         Pop();
 616         if( aOutSize.Height() - aStartPt.Y() > FIXEDLINE_TEXT_BORDER )
 617             aDecoView.DrawSeparator( Point( aStartPt.X(), aOutSize.Height()-1 ),
 618                                      Point( aStartPt.X(), aStartPt.Y() + FIXEDLINE_TEXT_BORDER ) );
 619         if( aStartPt.Y() - nWidth - FIXEDLINE_TEXT_BORDER > 0 )
 620             aDecoView.DrawSeparator( Point( aStartPt.X(), aStartPt.Y() - nWidth - FIXEDLINE_TEXT_BORDER ),
 621                                      Point( aStartPt.X(), 0 ) );
 622     }
 623     else
 624     {
 625         sal_uInt16      nStyle = TEXT_DRAW_MNEMONIC | TEXT_DRAW_LEFT | TEXT_DRAW_VCENTER | TEXT_DRAW_ENDELLIPSIS;
 626         Rectangle   aRect( 0, 0, aOutSize.Width(), aOutSize.Height() );
 627         const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 628         if( (nWinStyle & WB_CENTER) )
 629             nStyle |= TEXT_DRAW_CENTER;
 630
 631         if ( !IsEnabled() )
 632             nStyle |= TEXT_DRAW_DISABLE;
 633         if ( GetStyle() & WB_NOLABEL )
 634             nStyle &= ~TEXT_DRAW_MNEMONIC;
 635         if ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO )
 636             nStyle |= TEXT_DRAW_MONO;
 637
 638         DrawControlText( *this, aRect, aText, nStyle, pVector, pDisplayText );
 639
 640         if( !pVector )
 641         {
 642             long nTop = aRect.Top() + ((aRect.GetHeight()-1)/2);
 643             aDecoView.DrawSeparator( Point( aRect.Right()+FIXEDLINE_TEXT_BORDER, nTop ), Point( aOutSize.Width()-1, nTop ), false );
 644             if( aRect.Left() > FIXEDLINE_TEXT_BORDER )
 645                 aDecoView.DrawSeparator( Point( 0, nTop ), Point( aRect.Left()-FIXEDLINE_TEXT_BORDER, nTop ), false );
 646         }
 647     }
 648 }
 649
 650 // -----------------------------------------------------------------------
 651
 652 FixedLine::FixedLine( Window* pParent, WinBits nStyle ) :
 653     Control( WINDOW_FIXEDLINE )
 654 {
 655     ImplInit( pParent, nStyle );
 656     SetSizePixel( Size( 2, 2 ) );
 657 }
 658
 659 // -----------------------------------------------------------------------
 660
 661 FixedLine::FixedLine( Window* pParent, const ResId& rResId ) :
 662     Control( WINDOW_FIXEDLINE )
 663 {
 664     rResId.SetRT( RSC_FIXEDLINE );
 665     WinBits nStyle = ImplInitRes( rResId );
 666     ImplInit( pParent, nStyle );
 667     ImplLoadRes( rResId );
 668
 669     if ( !(nStyle & WB_HIDE) )
 670         Show();
 671 }
 672
 673 // -----------------------------------------------------------------------
 674
 675 void  FixedLine::FillLayoutData() const
 676 {
 677     mpControlData->mpLayoutData = new vcl::ControlLayoutData();
 678     const_cast<FixedLine*>(this)->ImplDraw( true );
 679 }
 680
 681
 682 // -----------------------------------------------------------------------
 683
 684 void FixedLine::Paint( const Rectangle& )
 685 {
 686     ImplDraw();
 687 }
 688
 689 // -----------------------------------------------------------------------
 690
 691 void FixedLine::Draw( OutputDevice*, const Point&, const Size&, sal_uLong )
 692 {
 693 }
 694
 695 // -----------------------------------------------------------------------
 696
 697 void FixedLine::Resize()
 698 {
 699     Control::Resize();
 700     Invalidate();
 701 }
 702
 703 // -----------------------------------------------------------------------
 704
 705 void FixedLine::StateChanged( StateChangedType nType )
 706 {
 707     Control::StateChanged( nType );
 708
 709     if ( (nType == STATE_CHANGE_ENABLE) ||
 710          (nType == STATE_CHANGE_TEXT) ||
 711          (nType == STATE_CHANGE_UPDATEMODE) )
 712     {
 713         if ( IsReallyVisible() && IsUpdateMode() )
 714             Invalidate();
 715     }
 716     else if ( nType == STATE_CHANGE_STYLE )
 717     {
 718         SetStyle( ImplInitStyle( GetStyle() ) );
 719         if ( (GetPrevStyle() & FIXEDLINE_VIEW_STYLE) !=
 720              (GetStyle() & FIXEDLINE_VIEW_STYLE) )
 721             Invalidate();
 722     }
 723     else if ( (nType == STATE_CHANGE_ZOOM)  ||
 724               (nType == STATE_CHANGE_STYLE) ||
 725               (nType == STATE_CHANGE_CONTROLFONT) )
 726     {
 727         ImplInitSettings( sal_True, sal_False, sal_False );
 728         Invalidate();
 729     }
 730     else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
 731     {
 732         ImplInitSettings( sal_False, sal_True, sal_False );
 733         Invalidate();
 734     }
 735     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 736     {
 737         ImplInitSettings( sal_False, sal_False, sal_True );
 738         Invalidate();
 739     }
 740 }
 741
 742 // -----------------------------------------------------------------------
 743
 744 void FixedLine::DataChanged( const DataChangedEvent& rDCEvt )
 745 {
 746     Control::DataChanged( rDCEvt );
 747
 748     if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
 749          (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
 750          ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 751           (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
 752     {
 753         ImplInitSettings( sal_True, sal_True, sal_True );
 754         Invalidate();
 755     }
 756 }
 757
 758 // -----------------------------------------------------------------------
 759
 760 Size FixedLine::GetOptimalSize() const
 761 {
 762     return CalcWindowSize( FixedText::CalcMinimumTextSize ( this, 0x7fffffff ) );
 763 }
 764
 765 // =======================================================================
 766
 767 void FixedBitmap::ImplInit( Window* pParent, WinBits nStyle )
 768 {
 769     nStyle = ImplInitStyle( nStyle );
 770     Control::ImplInit( pParent, nStyle, NULL );
 771     ImplInitSettings();
 772 }
 773
 774 // -----------------------------------------------------------------------
 775
 776 WinBits FixedBitmap::ImplInitStyle( WinBits nStyle )
 777 {
 778     if ( !(nStyle & WB_NOGROUP) )
 779         nStyle |= WB_GROUP;
 780     return nStyle;
 781 }
 782
 783 // -----------------------------------------------------------------------
 784
 785 void FixedBitmap::ImplInitSettings()
 786 {
 787     Window* pParent = GetParent();
 788     if ( pParent->IsChildTransparentModeEnabled() && !IsControlBackground() )
 789     {
 790         EnableChildTransparentMode( sal_True );
 791         SetParentClipMode( PARENTCLIPMODE_NOCLIP );
 792         SetPaintTransparent( sal_True );
 793         SetBackground();
 794     }
 795     else
 796     {
 797         EnableChildTransparentMode( sal_False );
 798         SetParentClipMode( 0 );
 799         SetPaintTransparent( sal_False );
 800
 801         if ( IsControlBackground() )
 802             SetBackground( GetControlBackground() );
 803         else
 804             SetBackground( pParent->GetBackground() );
 805     }
 806 }
 807
 808 // -----------------------------------------------------------------------
 809
 810 void FixedBitmap::ImplLoadRes( const ResId& rResId )
 811 {
 812     Control::ImplLoadRes( rResId );
 813
 814     sal_uLong nObjMask = ReadLongRes();
 815
 816     if ( RSC_FIXEDBITMAP_BITMAP & nObjMask )
 817     {
 818         maBitmap = Bitmap( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) );
 819         IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
 820     }
 821 }
 822
 823 // -----------------------------------------------------------------------
 824
 825 FixedBitmap::FixedBitmap( Window* pParent, WinBits nStyle ) :
 826     Control( WINDOW_FIXEDBITMAP )
 827 {
 828     ImplInit( pParent, nStyle );
 829 }
 830
 831 // -----------------------------------------------------------------------
 832
 833 FixedBitmap::FixedBitmap( Window* pParent, const ResId& rResId ) :
 834     Control( WINDOW_FIXEDBITMAP )
 835 {
 836     rResId.SetRT( RSC_FIXEDBITMAP );
 837     WinBits nStyle = ImplInitRes( rResId );
 838     ImplInit( pParent, nStyle );
 839     ImplLoadRes( rResId );
 840
 841     if ( !(nStyle & WB_HIDE) )
 842         Show();
 843 }
 844
 845 // -----------------------------------------------------------------------
 846
 847 FixedBitmap::~FixedBitmap()
 848 {
 849 }
 850
 851 // -----------------------------------------------------------------------
 852
 853 void FixedBitmap::ImplDraw( OutputDevice* pDev, sal_uLong /* nDrawFlags */,
 854                             const Point& rPos, const Size& rSize )
 855 {
 856     sal_uInt16 nStyle = 0;
 857     Bitmap* pBitmap = &maBitmap;
 858
 859     if( nStyle & IMAGE_DRAW_COLORTRANSFORM )
 860     {
 861         // only images support IMAGE_DRAW_COLORTRANSFORM
 862         Image aImage( maBitmap );
 863         if ( !(!aImage) )
 864         {
 865             if ( GetStyle() & WB_SCALE )
 866                 pDev->DrawImage( rPos, rSize, aImage, nStyle );
 867             else
 868             {
 869                 Point aPos = ImplCalcPos( GetStyle(), rPos, aImage.GetSizePixel(), rSize );
 870                 pDev->DrawImage( aPos, aImage, nStyle );
 871             }
 872         }
 873     }
 874     else
 875     {
 876         // do we have a Bitmap?
 877         if ( !(!(*pBitmap)) )
 878         {
 879             if ( GetStyle() & WB_SCALE )
 880                 pDev->DrawBitmap( rPos, rSize, *pBitmap );
 881             else
 882             {
 883                 Point aPos = ImplCalcPos( GetStyle(), rPos, pBitmap->GetSizePixel(), rSize );
 884                 pDev->DrawBitmap( aPos, *pBitmap );
 885             }
 886         }
 887     }
 888 }
 889
 890 // -----------------------------------------------------------------------
 891
 892 void FixedBitmap::Paint( const Rectangle& )
 893 {
 894     ImplDraw( this, 0, Point(), GetOutputSizePixel() );
 895 }
 896
 897 // -----------------------------------------------------------------------
 898
 899 void FixedBitmap::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
 900                         sal_uLong nFlags )
 901 {
 902     Point       aPos  = pDev->LogicToPixel( rPos );
 903     Size        aSize = pDev->LogicToPixel( rSize );
 904     Rectangle   aRect( aPos, aSize );
 905
 906     pDev->Push();
 907     pDev->SetMapMode();
 908
 909     // Border
 910     if ( !(nFlags & WINDOW_DRAW_NOBORDER) && (GetStyle() & WB_BORDER) )
 911     {
 912         DecorationView aDecoView( pDev );
 913         aRect = aDecoView.DrawFrame( aRect, FRAME_DRAW_DOUBLEIN );
 914     }
 915     pDev->IntersectClipRegion( aRect );
 916     ImplDraw( pDev, nFlags, aRect.TopLeft(), aRect.GetSize() );
 917
 918     pDev->Pop();
 919 }
 920
 921 // -----------------------------------------------------------------------
 922
 923 void FixedBitmap::Resize()
 924 {
 925     Control::Resize();
 926     Invalidate();
 927 }
 928
 929 // -----------------------------------------------------------------------
 930
 931 void FixedBitmap::StateChanged( StateChangedType nType )
 932 {
 933     Control::StateChanged( nType );
 934
 935     if ( (nType == STATE_CHANGE_DATA) ||
 936          (nType == STATE_CHANGE_UPDATEMODE) )
 937     {
 938         if ( IsReallyVisible() && IsUpdateMode() )
 939             Invalidate();
 940     }
 941     else if ( nType == STATE_CHANGE_STYLE )
 942     {
 943         SetStyle( ImplInitStyle( GetStyle() ) );
 944         if ( (GetPrevStyle() & FIXEDBITMAP_VIEW_STYLE) !=
 945              (GetStyle() & FIXEDBITMAP_VIEW_STYLE) )
 946             Invalidate();
 947     }
 948     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
 949     {
 950         ImplInitSettings();
 951         Invalidate();
 952     }
 953 }
 954
 955 // -----------------------------------------------------------------------
 956
 957 void FixedBitmap::DataChanged( const DataChangedEvent& rDCEvt )
 958 {
 959     Control::DataChanged( rDCEvt );
 960
 961     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 962          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 963     {
 964         ImplInitSettings();
 965         Invalidate();
 966     }
 967 }
 968
 969 // -----------------------------------------------------------------------
 970
 971 void FixedBitmap::SetBitmap( const Bitmap& rBitmap )
 972 {
 973     maBitmap = rBitmap;
 974     StateChanged( STATE_CHANGE_DATA );
 975     queue_resize();
 976 }
 977
 978 // =======================================================================
 979
 980 void FixedImage::ImplInit( Window* pParent, WinBits nStyle )
 981 {
 982     nStyle = ImplInitStyle( nStyle );
 983     mbInUserDraw = sal_False;
 984     Control::ImplInit( pParent, nStyle, NULL );
 985     ImplInitSettings();
 986 }
 987
 988 // -----------------------------------------------------------------------
 989
 990 WinBits FixedImage::ImplInitStyle( WinBits nStyle )
 991 {
 992     if ( !(nStyle & WB_NOGROUP) )
 993         nStyle |= WB_GROUP;
 994     return nStyle;
 995 }
 996
 997 // -----------------------------------------------------------------------
 998
 999 void FixedImage::ImplInitSettings()
1000 {
1001     Window* pParent = GetParent();
1002     if ( pParent && pParent->IsChildTransparentModeEnabled() && !IsControlBackground() )
1003     {
1004         EnableChildTransparentMode( sal_True );
1005         SetParentClipMode( PARENTCLIPMODE_NOCLIP );
1006         SetPaintTransparent( sal_True );
1007         SetBackground();
1008     }
1009     else
1010     {
1011         EnableChildTransparentMode( sal_False );
1012         SetParentClipMode( 0 );
1013         SetPaintTransparent( sal_False );
1014
1015         if ( IsControlBackground() )
1016             SetBackground( GetControlBackground() );
1017         else if ( pParent )
1018             SetBackground( pParent->GetBackground() );
1019     }
1020 }
1021
1022 // -----------------------------------------------------------------------
1023
1024 void FixedImage::ImplLoadRes( const ResId& rResId )
1025 {
1026     Control::ImplLoadRes( rResId );
1027
1028     sal_uLong nObjMask = ReadLongRes();
1029
1030     if ( RSC_FIXEDIMAGE_IMAGE & nObjMask )
1031     {
1032         maImage = Image( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) );
1033         IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
1034     }
1035 }
1036
1037 // -----------------------------------------------------------------------
1038
1039 FixedImage::FixedImage( Window* pParent, WinBits nStyle ) :
1040     Control( WINDOW_FIXEDIMAGE )
1041 {
1042     ImplInit( pParent, nStyle );
1043 }
1044
1045 // -----------------------------------------------------------------------
1046
1047 FixedImage::FixedImage( Window* pParent, const ResId& rResId ) :
1048     Control( WINDOW_FIXEDIMAGE )
1049 {
1050     rResId.SetRT( RSC_FIXEDIMAGE );
1051     WinBits nStyle = ImplInitRes( rResId );
1052     ImplInit( pParent, nStyle );
1053     ImplLoadRes( rResId );
1054
1055     if ( !(nStyle & WB_HIDE) )
1056         Show();
1057 }
1058
1059 // -----------------------------------------------------------------------
1060
1061 FixedImage::~FixedImage()
1062 {
1063 }
1064
1065 // -----------------------------------------------------------------------
1066
1067 void FixedImage::ImplDraw( OutputDevice* pDev, sal_uLong nDrawFlags,
1068                            const Point& rPos, const Size& rSize )
1069 {
1070     sal_uInt16 nStyle = 0;
1071     if ( !(nDrawFlags & WINDOW_DRAW_NODISABLE) )
1072     {
1073         if ( !IsEnabled() )
1074             nStyle |= IMAGE_DRAW_DISABLE;
1075     }
1076
1077     Image *pImage = &maImage;
1078
1079     // do we have an image?
1080     if ( !(!(*pImage)) )
1081     {
1082         if ( GetStyle() & WB_SCALE )
1083             pDev->DrawImage( rPos, rSize, *pImage, nStyle );
1084         else
1085         {
1086             Point aPos = ImplCalcPos( GetStyle(), rPos, pImage->GetSizePixel(), rSize );
1087             pDev->DrawImage( aPos, *pImage, nStyle );
1088         }
1089     }
1090
1091     mbInUserDraw = sal_True;
1092     UserDrawEvent aUDEvt( pDev, Rectangle( rPos, rSize ), 0, nStyle );
1093     UserDraw( aUDEvt );
1094     mbInUserDraw = sal_False;
1095 }
1096
1097 // -----------------------------------------------------------------------
1098
1099 void FixedImage::Paint( const Rectangle& )
1100 {
1101     ImplDraw( this, 0, Point(), GetOutputSizePixel() );
1102 }
1103
1104 // -----------------------------------------------------------------------
1105
1106 Size FixedImage::GetOptimalSize() const
1107 {
1108     return maImage.GetSizePixel();
1109 }
1110
1111 // -----------------------------------------------------------------------
1112
1113 void FixedImage::UserDraw( const UserDrawEvent& )
1114 {
1115 }
1116
1117 // -----------------------------------------------------------------------
1118
1119 void FixedImage::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
1120                        sal_uLong nFlags )
1121 {
1122     Point       aPos  = pDev->LogicToPixel( rPos );
1123     Size        aSize = pDev->LogicToPixel( rSize );
1124     Rectangle   aRect( aPos, aSize );
1125
1126     pDev->Push();
1127     pDev->SetMapMode();
1128
1129     // Border
1130     if ( !(nFlags & WINDOW_DRAW_NOBORDER) && (GetStyle() & WB_BORDER) )
1131     {
1132         ImplDrawFrame( pDev, aRect );
1133     }
1134     pDev->IntersectClipRegion( aRect );
1135     ImplDraw( pDev, nFlags, aRect.TopLeft(), aRect.GetSize() );
1136
1137     pDev->Pop();
1138 }
1139
1140 // -----------------------------------------------------------------------
1141
1142 void FixedImage::Resize()
1143 {
1144     Control::Resize();
1145     Invalidate();
1146 }
1147
1148 // -----------------------------------------------------------------------
1149
1150 void FixedImage::StateChanged( StateChangedType nType )
1151 {
1152     Control::StateChanged( nType );
1153
1154     if ( (nType == STATE_CHANGE_ENABLE) ||
1155          (nType == STATE_CHANGE_DATA) ||
1156          (nType == STATE_CHANGE_UPDATEMODE) )
1157     {
1158         if ( IsReallyVisible() && IsUpdateMode() )
1159             Invalidate();
1160     }
1161     else if ( nType == STATE_CHANGE_STYLE )
1162     {
1163         SetStyle( ImplInitStyle( GetStyle() ) );
1164         if ( (GetPrevStyle() & FIXEDIMAGE_VIEW_STYLE) !=
1165              (GetStyle() & FIXEDIMAGE_VIEW_STYLE) )
1166             Invalidate();
1167     }
1168     else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
1169     {
1170         ImplInitSettings();
1171         Invalidate();
1172     }
1173 }
1174
1175 // -----------------------------------------------------------------------
1176
1177 void FixedImage::DataChanged( const DataChangedEvent& rDCEvt )
1178 {
1179     Control::DataChanged( rDCEvt );
1180
1181     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1182          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
1183     {
1184         ImplInitSettings();
1185         Invalidate();
1186     }
1187 }
1188
1189 // -----------------------------------------------------------------------
1190
1191 void FixedImage::SetImage( const Image& rImage )
1192 {
1193     if ( rImage != maImage )
1194     {
1195         maImage = rImage;
1196         StateChanged( STATE_CHANGE_DATA );
1197         queue_resize();
1198     }
1199 }
1200
1201 // -----------------------------------------------------------------------
1202
1203 sal_Bool FixedImage::SetModeImage( const Image& rImage )
1204 {
1205     SetImage( rImage );
1206     return sal_True;
1207 }
1208
1209 // -----------------------------------------------------------------------
1210
1211 const Image& FixedImage::GetModeImage( ) const
1212 {
1213     return maImage;
1214 }
1215
1216 bool FixedImage::set_property(const OString &rKey, const OString &rValue)
1217 {
1218     if (rKey == "pixbuf")
1219     {
1220         static ImplImageTreeSingletonRef aImageTree;
1221         OUString sCurrentSymbolsStyle =
1222             Application::GetSettings().GetStyleSettings().GetCurrentSymbolsStyleName();
1223         const OUString sFileName(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
1224         BitmapEx aBitmap;
1225         bool bSuccess = aImageTree->loadImage(sFileName, sCurrentSymbolsStyle, aBitmap, true);
1226         SAL_WARN_IF(!bSuccess, "vcl.layout", "Unable to load " << sFileName
1227             << " from theme " << sCurrentSymbolsStyle);
1228         SetImage(Image(aBitmap));
1229     }
1230     else
1231         return Control::set_property(rKey, rValue);
1232     return true;
1233 }
1234
1235 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */