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