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